sumup 0.5.14

// The contents of this file are generated; do not modify them.

//! A Merchant represents a single business which can use SumUp products like payment processing.
use super::common::*;
/// An address somewhere in the world. The address fields used depend on the country conventions. For example, in Great Britain, `city` is `post_town`. In the United States, the top-level administrative unit used in addresses is `state`, whereas in Chile it's `region`.
/// Whether an address is valid or not depends on whether the locally required fields are present. Fields not supported in a country will be ignored.
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Address {
    /// In Spain, an autonomous community is the first sub-national level of political and administrative division.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `Catalonia`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub autonomous_community: Option<String>,
    /// The city of the address.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `Berlin`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    /// In many countries, terms cognate with "commune" are used, referring to the community living in the area and the common interest. Used in countries such as Chile.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `Providencia`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub commune: Option<String>,
    pub country: CountryCode,
    /// A county is a geographic region of a country used for administrative or other purposes in some nations. Used in countries such as Ireland, Romania, etc.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `Dublin County`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub county: Option<String>,
    /// A department (French: département, Spanish: departamento) is an administrative or political division in several countries. Used in countries such as Colombia.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `Antioquia`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub department: Option<String>,
    /// A district is a type of administrative division that in some countries is managed by the local government. Used in countries such as Portugal.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `Lisbon District`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub district: Option<String>,
    /// A postal address in Ireland.
    ///
    /// Constraints:
    /// - max length: 10
    ///
    /// Example: `D02 X285`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub eircode: Option<String>,
    /// A municipality is usually a single administrative division having corporate status and powers of self-government or jurisdiction as granted by national and regional laws to which it is subordinate. Used in countries such as Colombia.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `Medellín`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub municipality: Option<String>,
    /// Locality level of the address. Used in countries such as Brazil or Chile.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `Copacabana`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub neighborhood: Option<String>,
    /// The postal code (aka. zip code) of the address.
    ///
    /// Constraints:
    /// - max length: 10
    ///
    /// Example: `10999`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub post_code: Option<String>,
    /// A post town is a required part of all postal addresses in the United Kingdom and Ireland, and a basic unit of the postal delivery system.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `London`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub post_town: Option<String>,
    /// The province where the address is located. This may not be relevant in some countries.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `Berlin`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
    /// The region where the address is located. This may not be relevant in some countries.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `Baden Wuerttemberg`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub region: Option<String>,
    /// Most often, a country has a single state, with various administrative divisions. The term "state" is sometimes used to refer to the federated polities that make up the federation. Used in countries such as the United States and Brazil.
    ///
    /// Constraints:
    /// - max length: 60
    ///
    /// Example: `California`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_address: Option<Vec<String>>,
    /// A US system of postal codes used by the United States Postal Service (USPS).
    ///
    /// Constraints:
    /// - max length: 10
    ///
    /// Example: `94103`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip_code: Option<String>,
}
/// Base schema for a Person associated with a Merchant. This can be a legal representative, business owner (ultimate beneficial owner), or an officer. A legal representative is the Person who registered the Merchant with SumUp. They should always have a `user_id`.
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct BasePerson {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<Address>,
    /// The date of birth of the individual, represented as an ISO 8601:2004 [ISO8601‑2004] YYYY-MM-DD format.
    ///
    /// Example: `1980-01-12`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub birthdate: Option<crate::datetime::Date>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub change_status: Option<ChangeStatus>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub citizenship: Option<CountryCode>,
    /// An [ISO3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) country code representing the country where the Person resides.
    ///
    /// Constraints:
    /// - pattern: `^[A-Z]{2}$`
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        deserialize_with = "crate::nullable::deserialize"
    )]
    pub country_of_residence: Option<crate::Nullable<String>>,
    /// The last name(s) of the individual.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 60
    ///
    /// Example: `Bond`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub family_name: Option<String>,
    /// The first name(s) of the individual.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 60
    ///
    /// Example: `James Herrald`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub given_name: Option<String>,
    /// The unique identifier for the Person. This is a [typeid](https://github.com/sumup/typeid).
    ///
    /// Constraints:
    /// - read-only
    ///
    /// Example: `pers_2EGQ057R6C8J791RVCG5NWAEAB`
    pub id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub identifiers: Option<PersonalIdentifiers>,
    /// Middle name(s) of the End-User. Note that in some cultures, people can have multiple middle names; all can be present, with the names being separated by space characters. Also note that in some cultures, middle names are not used.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 60
    ///
    /// Example: `Maria Sophie`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub middle_name: Option<String>,
    /// The Person's nationality. May be an [ISO3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) country code, but legacy data may not conform to this standard.
    ///
    /// Constraints:
    /// - pattern: `^[A-Z]{2}$`
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        deserialize_with = "crate::nullable::deserialize"
    )]
    pub nationality: Option<crate::Nullable<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ownership: Option<Ownership>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<PhoneNumber>,
    /// A list of roles the Person has in the Merchant or towards SumUp. A Merchant must have at least one Person with the relationship `representative`.
    ///
    /// Constraints:
    /// - min items: 1
    /// - max items: 1
    #[serde(skip_serializing_if = "Option::is_none")]
    pub relationships: Option<Vec<String>>,
    /// A corresponding identity user ID for the Person, if they have a user account.
    ///
    /// Example: `ef263f37-8701-4181-9758-acddbb778ee9`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<Version>,
}
/// Settings used to apply the Merchant's branding to email receipts, invoices, checkouts, and other products.
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Branding {
    /// A hex color value representing the preferred background color of this merchant.
    ///
    /// Example: `#FF4B3A`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub background_color: Option<String>,
    /// Footer text rendered on receipts and other customer-facing products.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 500
    ///
    /// Example: `Thanks for shopping with us.`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub footer_text: Option<String>,
    /// Data-URL encoded hero image for the merchant business.
    ///
    /// Constraints:
    /// - format: `uri`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hero: Option<String>,
    /// An icon for the merchant. Must be square.
    ///
    /// Constraints:
    /// - format: `uri`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    /// A logo for the merchant that will be used in place of the icon and without the merchant's name next to it if there's sufficient space.
    ///
    /// Constraints:
    /// - format: `uri`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub logo: Option<String>,
    /// A hex color value representing the primary branding color of this merchant (your brand color).
    ///
    /// Example: `#FF4B3A`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub primary_color: Option<String>,
    /// A hex color value representing the color of the text displayed on branding color of this merchant.
    ///
    /// Example: `#FF4B3A`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub primary_color_fg: Option<String>,
    /// A hex color value representing the secondary branding color of this merchant (accent color used for buttons).
    ///
    /// Example: `#FF4B3A`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub secondary_color: Option<String>,
    /// A hex color value representing the color of the text displayed on secondary branding color of this merchant.
    ///
    /// Example: `#FF4B3A`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub secondary_color_fg: Option<String>,
}
/// Business information about the merchant. This information will be visible to the merchant's customers.
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct BusinessProfile {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<Address>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub branding: Option<Branding>,
    /// The descriptor is the text that your customer sees on their bank account statement.
    /// The more recognisable your descriptor is, the less risk you have of receiving disputes (e.g. chargebacks).
    ///
    /// Constraints:
    /// - pattern: `^[a-zA-Z0-9 +'_.-]+$`
    /// - min length: 1
    /// - max length: 30
    ///
    /// Example: `Example Coffee`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_descriptor: Option<String>,
    /// A publicly available email address.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 255
    ///
    /// Example: `contact@example.com`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    /// The customer-facing business name.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 150
    ///
    /// Example: `Example Coffee`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<PhoneNumber>,
    /// The business's publicly available website.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 255
    ///
    /// Example: `https://example.com`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub website: Option<String>,
}
/// Reflects the status of changes submitted through the `PATCH` endpoints for the Merchant or Persons. If some changes have not been applied yet, the status will be `pending`. If all changes have been applied, the status `done`.
/// The status is only returned after write operations or on read endpoints when the `version` query parameter is provided.
///
/// Constraints:
/// - read-only
pub type ChangeStatus = String;
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct ClassicMerchantIdentifiers {
    /// Classic (serial) merchant ID.
    ///
    /// Example: `1234`
    #[deprecated]
    pub id: i64,
}
/// Information about the company or business. This is legal information that is used for verification.
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Company {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<Address>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attributes: Option<Attributes>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub identifiers: Option<CompanyIdentifiers>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub legal_type: Option<LegalType>,
    /// The merchant category code for the account as specified by [ISO18245](https://www.iso.org/standard/33365.html). MCCs are used to classify businesses based on the goods or services they provide.
    ///
    /// Constraints:
    /// - pattern: `^[0-9]{4}$`
    ///
    /// Example: `1532`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub merchant_category_code: Option<String>,
    /// The company's legal name.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 150
    ///
    /// Example: `Gin & Doughnuts Bar GmbH`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<PhoneNumber>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trading_address: Option<Address>,
    /// HTTP(S) URL of the company's website.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 255
    ///
    /// Example: `https://www.sumup.com`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub website: Option<String>,
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct CompanyIdentifier {
    /// The unique reference for the company identifier type as defined in the country SDK.
    ///
    /// Constraints:
    /// - pattern: `^[a-z]{2}\.[a-z_]+$`
    ///
    /// Example: `de.gmbh`
    #[serde(rename = "ref")]
    pub r#ref: String,
    /// The company identifier value.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 100
    ///
    /// Example: `HRB 123456`
    pub value: String,
}
/// A list of country-specific company identifiers.
pub type CompanyIdentifiers = Vec<CompanyIdentifier>;
/// An [ISO3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2)
/// country code. This definition users `oneOf` with a two-character string
/// type to allow for support of future countries in client code.
///
/// Constraints:
/// - pattern: `^[A-Z]{2}$`
/// - min length: 2
/// - max length: 2
///
/// Example: `BR`
pub type CountryCode = String;
/// The unique legal type reference as defined in the country SDK. We do not rely on IDs as used by other services. Consumers of this API are expected to use the country SDK to map to any other IDs, translation keys, or descriptions.
///
/// Constraints:
/// - pattern: `^[a-z]{2}\.[a-z_]+$`
/// - min length: 4
/// - max length: 64
///
/// Example: `de.freiberufler`
pub type LegalType = String;
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct ListPersonsResponseBody {
    pub items: Vec<Person>,
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Merchant {
    /// A user-facing name of the merchant account for use in dashboards and other user-facing applications. For customer-facing business name see `merchant.business_profile`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alias: Option<String>,
    /// A user-facing small-format logo for use in dashboards and other user-facing applications. For customer-facing branding see `merchant.business_profile.branding`.
    ///
    /// Constraints:
    /// - format: `uri`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub avatar: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub business_profile: Option<BusinessProfile>,
    /// The business type.
    /// * `sole_trader`: The business is run by an self-employed individual.
    /// * `company`: The business is run as a company with one or more shareholders
    /// * `partnership`: The business is run as a company with two or more shareholders that can be also other legal entities
    /// * `non_profit`: The business is run as a nonprofit organization that operates for public or social benefit
    /// * `government_entity`: The business is state owned and operated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub business_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub change_status: Option<ChangeStatus>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub classic: Option<ClassicMerchantIdentifiers>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub company: Option<Company>,
    pub country: CountryCode,
    /// The date and time when the resource was created. This is a string as defined in [RFC 3339, section 5.6](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6).
    ///
    /// Constraints:
    /// - read-only
    ///
    /// Example: `2021-08-31T12:00:00Z`
    pub created_at: crate::datetime::DateTime,
    /// Three-letter [ISO currency code](https://en.wikipedia.org/wiki/ISO_4217) representing the default currency for the account.
    ///
    /// Constraints:
    /// - read-only
    /// - min length: 3
    /// - max length: 3
    ///
    /// Example: `EUR`
    pub default_currency: String,
    /// Merchant's default locale, represented as a BCP47 [RFC5646](https://datatracker.ietf.org/doc/html/rfc5646) language tag. This is typically an ISO 639-1 Alpha-2 [ISO639‑1](https://www.iso.org/iso-639-language-code) language code in lowercase and an ISO 3166-1 Alpha-2 [ISO3166‑1](https://www.iso.org/iso-3166-country-codes.html) country code in uppercase, separated by a dash. For example, en-US or fr-CA.
    /// In multilingual countries this is the merchant's preferred locale out of those, that are officially spoken in the country. In a countries with a single official language this will match the official language.
    ///
    /// Constraints:
    /// - min length: 2
    /// - max length: 5
    ///
    /// Example: `de-DE`
    pub default_locale: String,
    /// Short unique identifier for the merchant.
    ///
    /// Constraints:
    /// - read-only
    ///
    /// Example: `MK01A8C2`
    pub merchant_code: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meta: Option<Meta>,
    /// ID of the organization the merchant belongs to (if any).
    ///
    /// Example: `G0UZPVAX`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub organization_id: Option<String>,
    /// True if the merchant is a sandbox for testing.
    ///
    /// Example: `false`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sandbox: Option<bool>,
    /// The date and time when the resource was last updated. This is a string as defined in [RFC 3339, section 5.6](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6).
    ///
    /// Constraints:
    /// - read-only
    ///
    /// Example: `2021-08-31T12:00:00Z`
    pub updated_at: crate::datetime::DateTime,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<Version>,
}
/// A set of key-value pairs that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
///
/// **Warning**: Updating Meta will overwrite the existing data. Make sure to always include the complete JSON object.
#[derive(Debug, Clone, Default, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Meta {
    #[serde(
        flatten,
        default,
        skip_serializing_if = "std::collections::HashMap::is_empty"
    )]
    pub additional_properties: std::collections::HashMap<String, String>,
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Ownership {
    /// The percent of ownership shares held by the Person expressed in percent mille (1/100000). Only Persons with the relationship `owner` can have ownership.
    ///
    /// Constraints:
    /// - value >= 25000
    /// - value <= 100000
    ///
    /// Example: `50000`
    pub share: i32,
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Person {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<Address>,
    /// The date of birth of the individual, represented as an ISO 8601:2004 [ISO8601‑2004] YYYY-MM-DD format.
    ///
    /// Example: `1980-01-12`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub birthdate: Option<crate::datetime::Date>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub change_status: Option<ChangeStatus>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub citizenship: Option<CountryCode>,
    /// An [ISO3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) country code representing the country where the Person resides.
    ///
    /// Constraints:
    /// - pattern: `^[A-Z]{2}$`
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        deserialize_with = "crate::nullable::deserialize"
    )]
    pub country_of_residence: Option<crate::Nullable<String>>,
    /// The last name(s) of the individual.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 60
    ///
    /// Example: `Bond`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub family_name: Option<String>,
    /// The first name(s) of the individual.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 60
    ///
    /// Example: `James Herrald`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub given_name: Option<String>,
    /// The unique identifier for the Person. This is a [typeid](https://github.com/sumup/typeid).
    ///
    /// Constraints:
    /// - read-only
    ///
    /// Example: `pers_2EGQ057R6C8J791RVCG5NWAEAB`
    pub id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub identifiers: Option<PersonalIdentifiers>,
    /// Middle name(s) of the End-User. Note that in some cultures, people can have multiple middle names; all can be present, with the names being separated by space characters. Also note that in some cultures, middle names are not used.
    ///
    /// Constraints:
    /// - min length: 1
    /// - max length: 60
    ///
    /// Example: `Maria Sophie`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub middle_name: Option<String>,
    /// The Person's nationality. May be an [ISO3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2) country code, but legacy data may not conform to this standard.
    ///
    /// Constraints:
    /// - pattern: `^[A-Z]{2}$`
    #[serde(
        default,
        skip_serializing_if = "Option::is_none",
        deserialize_with = "crate::nullable::deserialize"
    )]
    pub nationality: Option<crate::Nullable<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ownership: Option<Ownership>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<PhoneNumber>,
    /// A list of roles the Person has in the Merchant or towards SumUp. A Merchant must have at least one Person with the relationship `representative`.
    ///
    /// Constraints:
    /// - min items: 1
    /// - max items: 1
    #[serde(skip_serializing_if = "Option::is_none")]
    pub relationships: Option<Vec<String>>,
    /// A corresponding identity user ID for the Person, if they have a user account.
    ///
    /// Example: `ef263f37-8701-4181-9758-acddbb778ee9`
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<Version>,
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct PersonalIdentifier {
    /// The unique reference for the personal identifier type.
    ///
    /// Constraints:
    /// - max length: 32
    ///
    /// Example: `br.cpf`
    #[serde(rename = "ref")]
    pub r#ref: String,
    /// The personal identifier value.
    ///
    /// Constraints:
    /// - max length: 128
    ///
    /// Example: `847.060.136-90`
    pub value: String,
}
/// A list of country-specific personal identifiers.
///
/// Constraints:
/// - max items: 32
pub type PersonalIdentifiers = Vec<PersonalIdentifier>;
/// A publicly available phone number in [E.164](https://en.wikipedia.org/wiki/E.164) format.
///
/// Constraints:
/// - max length: 16
///
/// Example: `+420123456789`
pub type PhoneNumber = String;
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Timestamps {
    /// The date and time when the resource was created. This is a string as defined in [RFC 3339, section 5.6](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6).
    ///
    /// Constraints:
    /// - read-only
    ///
    /// Example: `2021-08-31T12:00:00Z`
    pub created_at: crate::datetime::DateTime,
    /// The date and time when the resource was last updated. This is a string as defined in [RFC 3339, section 5.6](https://datatracker.ietf.org/doc/html/rfc3339#section-5.6).
    ///
    /// Constraints:
    /// - read-only
    ///
    /// Example: `2021-08-31T12:00:00Z`
    pub updated_at: crate::datetime::DateTime,
}
/// The version of the resource. The version reflects a specific change submitted to the API via one of the `PATCH` endpoints.
///
/// Example: `chng_01HS0KG3MPVEVWW85E3KNXH55J`
pub type Version = String;
use crate::client::Client;
#[derive(Debug, PartialEq)]
pub enum GetErrorBody {
    NotFound(Problem),
}
#[derive(Debug, PartialEq)]
pub enum ListPersonsErrorBody {
    NotFound(Problem),
}
#[derive(Debug, PartialEq)]
pub enum GetPersonErrorBody {
    NotFound(Problem),
}
/// Client for the Merchants API endpoints.
#[derive(Debug)]
pub struct MerchantsClient<'a> {
    client: &'a Client,
}
impl<'a> MerchantsClient<'a> {
    pub(crate) fn new(client: &'a Client) -> Self {
        Self { client }
    }
    /// Returns a reference to the underlying client.
    pub fn client(&self) -> &Client {
        self.client
    }
    /// Get Merchant
    ///
    /// Returns a Merchant for a valid Merchant code.
    ///
    /// Responses:
    /// - 200: Returns a Merchant for a valid identifier.
    /// - 404: The requested Merchant does not exist.
    pub async fn get(
        &self,
        merchant_code: impl Into<String>,
    ) -> crate::error::SdkResult<Merchant, GetErrorBody> {
        let path = format!("/v1/merchants/{}", merchant_code.into());
        let url = format!("{}{}", self.client.base_url(), path);
        let mut request = self
            .client
            .http_client()
            .get(&url)
            .header("User-Agent", crate::version::user_agent())
            .timeout(self.client.timeout());
        if let Some(authorization) = self.client.authorization() {
            request = request.header("Authorization", format!("Bearer {}", authorization));
        }
        for (header_name, header_value) in self.client.runtime_headers() {
            request = request.header(*header_name, header_value);
        }
        let response = request.send().await?;
        let status = response.status();
        match status {
            reqwest::StatusCode::OK => {
                let data: Merchant = response.json().await?;
                Ok(data)
            }
            reqwest::StatusCode::NOT_FOUND => {
                let body: Problem = response.json().await?;
                Err(crate::error::SdkError::api(GetErrorBody::NotFound(body)))
            }
            _ => {
                let body_bytes = response.bytes().await?;
                let body = crate::error::UnknownApiBody::from_bytes(body_bytes.as_ref());
                Err(crate::error::SdkError::unexpected(status, body))
            }
        }
    }
    /// List Persons
    ///
    /// Returns the Persons related to a Merchant.
    ///
    /// Responses:
    /// - 200: Returns a list of Persons for a valid Merchant identifier.
    /// - 404: The requested Merchant does not exist.
    pub async fn list_persons(
        &self,
        merchant_code: impl Into<String>,
    ) -> crate::error::SdkResult<ListPersonsResponseBody, ListPersonsErrorBody> {
        let path = format!("/v1/merchants/{}/persons", merchant_code.into());
        let url = format!("{}{}", self.client.base_url(), path);
        let mut request = self
            .client
            .http_client()
            .get(&url)
            .header("User-Agent", crate::version::user_agent())
            .timeout(self.client.timeout());
        if let Some(authorization) = self.client.authorization() {
            request = request.header("Authorization", format!("Bearer {}", authorization));
        }
        for (header_name, header_value) in self.client.runtime_headers() {
            request = request.header(*header_name, header_value);
        }
        let response = request.send().await?;
        let status = response.status();
        match status {
            reqwest::StatusCode::OK => {
                let data: ListPersonsResponseBody = response.json().await?;
                Ok(data)
            }
            reqwest::StatusCode::NOT_FOUND => {
                let body: Problem = response.json().await?;
                Err(crate::error::SdkError::api(ListPersonsErrorBody::NotFound(
                    body,
                )))
            }
            _ => {
                let body_bytes = response.bytes().await?;
                let body = crate::error::UnknownApiBody::from_bytes(body_bytes.as_ref());
                Err(crate::error::SdkError::unexpected(status, body))
            }
        }
    }
    /// Get Person
    ///
    /// Returns a single Person related to a Merchant.
    ///
    /// Responses:
    /// - 200: Returns a Person for a valid identifier.
    /// - 404: The requested Person does not exist.
    pub async fn get_person(
        &self,
        merchant_code: impl Into<String>,
        person_id: impl Into<String>,
    ) -> crate::error::SdkResult<Person, GetPersonErrorBody> {
        let path = format!(
            "/v1/merchants/{}/persons/{}",
            merchant_code.into(),
            person_id.into()
        );
        let url = format!("{}{}", self.client.base_url(), path);
        let mut request = self
            .client
            .http_client()
            .get(&url)
            .header("User-Agent", crate::version::user_agent())
            .timeout(self.client.timeout());
        if let Some(authorization) = self.client.authorization() {
            request = request.header("Authorization", format!("Bearer {}", authorization));
        }
        for (header_name, header_value) in self.client.runtime_headers() {
            request = request.header(*header_name, header_value);
        }
        let response = request.send().await?;
        let status = response.status();
        match status {
            reqwest::StatusCode::OK => {
                let data: Person = response.json().await?;
                Ok(data)
            }
            reqwest::StatusCode::NOT_FOUND => {
                let body: Problem = response.json().await?;
                Err(crate::error::SdkError::api(GetPersonErrorBody::NotFound(
                    body,
                )))
            }
            _ => {
                let body_bytes = response.bytes().await?;
                let body = crate::error::UnknownApiBody::from_bytes(body_bytes.as_ref());
                Err(crate::error::SdkError::unexpected(status, body))
            }
        }
    }
}