Struct AccountCreateRequest 

pub struct AccountCreateRequest {

    pub account_subtype: Option<String>,
    pub account_type: String,
    pub apr: Option<f64>,
    pub apy: Option<f64>,
    pub available_balance: Option<f64>,
    pub balance: Option<f64>,
    pub cash_surrender_value: Option<f64>,
    pub credit_limit: Option<f64>,
    pub currency_code: Option<String>,
    pub death_benefit: Option<i64>,
    pub interest_rate: Option<f64>,
    pub is_business: Option<bool>,
    pub is_closed: Option<bool>,
    pub is_hidden: Option<bool>,
    pub loan_amount: Option<f64>,
    pub metadata: Option<String>,
    pub name: String,
    pub nickname: Option<String>,
    pub original_balance: Option<f64>,
    pub property_type: Option<String>,
    pub skip_webhook: Option<bool>,
}

AccountCreateRequest

JSON schema

{
 "type": "object",
 "required": [
   "account_type",
   "name"
 ],
 "properties": {
   "account_subtype": {
     "examples": [
       "PERSONAL"
     ],
     "type": "string"
   },
   "account_type": {
     "examples": [
       "SAVINGS"
     ],
     "type": "string"
   },
   "apr": {
     "examples": [
       1
     ],
     "type": "number"
   },
   "apy": {
     "examples": [
       1
     ],
     "type": "number"
   },
   "available_balance": {
     "examples": [
       1000
     ],
     "type": "number"
   },
   "balance": {
     "examples": [
       1000
     ],
     "type": "number"
   },
   "cash_surrender_value": {
     "examples": [
       1000
     ],
     "type": "number"
   },
   "credit_limit": {
     "examples": [
       100
     ],
     "type": "number"
   },
   "currency_code": {
     "examples": [
       "USD"
     ],
     "type": "string"
   },
   "death_benefit": {
     "examples": [
       1000
     ],
     "type": "integer"
   },
   "interest_rate": {
     "examples": [
       1
     ],
     "type": "number"
   },
   "is_business": {
     "examples": [
       false
     ],
     "type": "boolean"
   },
   "is_closed": {
     "examples": [
       false
     ],
     "type": "boolean"
   },
   "is_hidden": {
     "examples": [
       false
     ],
     "type": "boolean"
   },
   "loan_amount": {
     "examples": [
       1000
     ],
     "type": "number"
   },
   "metadata": {
     "examples": [
       "some metadata"
     ],
     "type": "string"
   },
   "name": {
     "examples": [
       "Test account 2"
     ],
     "type": "string"
   },
   "nickname": {
     "examples": [
       "Swiss Account"
     ],
     "type": "string"
   },
   "original_balance": {
     "examples": [
       10
     ],
     "type": "number"
   },
   "property_type": {
     "examples": [
       "VEHICLE"
     ],
     "type": "string"
   },
   "skip_webhook": {
     "examples": [
       true
     ],
     "type": "boolean"
   }
 }
}

Fields

account_subtype: Option<String>

account_type: String

apr: Option<f64>

apy: Option<f64>

available_balance: Option<f64>

balance: Option<f64>

cash_surrender_value: Option<f64>

credit_limit: Option<f64>

currency_code: Option<String>

death_benefit: Option<i64>

interest_rate: Option<f64>

is_business: Option<bool>

is_closed: Option<bool>

is_hidden: Option<bool>

loan_amount: Option<f64>

metadata: Option<String>

name: String

nickname: Option<String>

original_balance: Option<f64>

property_type: Option<String>

skip_webhook: Option<bool>

Trait Implementations

impl Clone for AccountCreateRequest

fn clone(&self) -> AccountCreateRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AccountCreateRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AccountCreateRequest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&AccountCreateRequest> for AccountCreateRequest

fn from(value: &AccountCreateRequest) -> Self

Converts to this type from the input type.

impl Serialize for AccountCreateRequest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.