Struct Field64 

pub struct Field64 {
    pub debit_credit_mark: String,
    pub value_date: NaiveDate,
    pub currency: String,
    pub amount: f64,
}

Field 64: Closing Available Balance

Purpose

Specifies the closing available balance of an account, representing the funds that are immediately available for use by the account holder. This field distinguishes between the book balance (Field 62) and the available balance, accounting for holds, pending transactions, and other restrictions that may limit fund availability.

Business Context Applications

• Cash Management: Available funds for immediate use
• Liquidity Assessment: Actual usable funds for operations
• Credit Decisions: Available balance for credit facilities
• Risk Management: Available funds for risk assessment

Network Validation Requirements

• Date Validation: Value date must be valid calendar date
• Currency Validation: Must be valid ISO 4217 currency code
• Amount Format: Decimal amount with proper precision
• Mark Validation: Debit/Credit mark must be D (Debit) or C (Credit)
• Balance Logic: Available balance should not exceed book balance for most scenarios

Available Balance Calculation

Balance Components

Available Balance = Book Balance - Holds - Pending Debits + Pending Credits - Reserves

Availability Factors

• Holds: Funds held for pending transactions or legal requirements
• Float: Funds not yet cleared or collected
• Reserves: Required reserves or minimum balance requirements
• Credit Facilities: Available credit lines that increase available balance

Regional Considerations

• European Banking: European fund availability regulations
• US Banking: Regulation CC and fund availability requirements
• Asian Markets: Local fund availability and hold practices
• Cross-Border: International fund availability considerations

Error Prevention Guidelines

• Balance Logic: Verify available balance is consistent with book balance
• Date Alignment: Ensure value date aligns with statement period
• Currency Consistency: Verify currency matches account currency
• Amount Validation: Confirm precision meets currency standards

Related Fields Integration

• Field 62: Closing Balance (book balance comparison)
• Field 65: Forward Available Balance (future availability)
• Field 60: Opening Balance (period context)
• Field 61: Statement Line (transactions affecting availability)

Compliance Framework

• Regulatory Requirements: Fund availability disclosure requirements
• Consumer Protection: Clear communication of available funds
• Risk Management: Available balance for credit and operational risk
• Audit Documentation: Proper available balance calculation documentation

See Also

• Swift FIN User Handbook: Available Balance Specifications

• Banking Regulations: Fund Availability Requirements

• Cash Management Standards: Available Balance Calculation

• Risk Management: Available Fund Assessment

  Field 64: Closing Available Balance Structure

Contains the closing available balance with debit/credit indication, value date, currency, and amount representing immediately usable funds.

Fields

debit_credit_mark: String

Debit or Credit mark

Format: 1!a - ‘D’ (Debit) or ‘C’ (Credit) Indicates whether the available balance is a debit or credit position

value_date: NaiveDate

Value date of the available balance

Format: 6!n (YYMMDD) - Date when balance is effective Typically aligns with statement period end date

currency: String

Currency of the available balance

Format: 3!a - ISO 4217 currency code (USD, EUR, GBP, etc.) Must match account currency for consistency

amount: f64

Available balance amount

Format: 15d - Decimal amount with comma separator Represents funds immediately available for use

Trait Implementations

impl Clone for Field64

fn clone(&self) -> Field64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Field64

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Field64

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Field64

fn eq(&self, other: &Field64) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Field64

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SwiftField for Field64

fn parse(value: &str) -> Result<Self>

Parse field value from string representation

fn to_swift_string(&self) -> String

Convert field back to SWIFT string format

fn format_spec() -> &'static str

Get field format specification

fn parse_with_variant( value: &str, _variant: Option<&str>, _field_tag: Option<&str>, ) -> Result<Self>

where Self: Sized,

Parse field value with variant hint for enum fields Default implementation falls back to regular parse

fn valid_variants() -> Option<Vec<&'static str>>

Get valid variant letters for enum fields Returns None for non-enum fields, Some(vec) for enum fields

impl StructuralPartialEq for Field64