Struct Field26T

pub struct Field26T {
    pub transaction_type_code: String,
}

Field 26T: Transaction Type Code

Overview

Field 26T contains a transaction type code that categorizes the nature of the transaction according to EUROSTAT Balance of Payments (BoP) guidelines. This field is mandatory for statistical reporting purposes and helps financial institutions classify cross-border transactions for regulatory compliance and economic analysis.

Format Specification

Format: 3!c

• 3!c: Exactly 3 alphanumeric characters
• Character set: A-Z, 0-9 (uppercase letters and digits)
• Case handling: Automatically converted to uppercase
• Validation: Must be exactly 3 characters, alphanumeric only

EUROSTAT Balance of Payments Categories

The transaction type codes follow EUROSTAT BoP methodology for statistical classification:

Goods (A-series)

• A01: General merchandise on a gross basis - Standard trade in goods
• A02: Goods for processing - Goods sent for processing abroad
• A03: Repairs on goods - Repair services on movable goods

Services (B-series)

• B01: Manufacturing services on physical inputs owned by others
• B02: Maintenance and repair services n.i.e. (not included elsewhere)
• B03: Transport services - Passenger and freight transport

Primary Income (C-series)

• C01: Compensation of employees - Wages, salaries, and benefits
• C02: Investment income - Dividends, interest, and other investment returns

Secondary Income (D-series)

• D01: General government transfers - Government-to-government transfers
• D02: Other sectors transfers - Private transfers and remittances

Capital Account (E-series)

• E01: Capital transfers - Non-financial asset transfers
• E02: Acquisition/disposal of non-produced, non-financial assets

Financial Account (F-series)

• F01: Direct investment - Foreign direct investment flows
• F02: Portfolio investment - Securities and equity investments
• F03: Financial derivatives - Derivative instruments
• F04: Other investment - Loans, deposits, and other financial instruments
• F05: Reserve assets - Central bank reserves

Usage Context

Field 26T is used in various SWIFT MT message types for statistical reporting:

• MT103: Single Customer Credit Transfer (when required by regulation)
• MT202: General Financial Institution Transfer
• MT202COV: Cover for customer credit transfer
• MT205: Financial Institution Transfer for its Own Account
• Cross-border payments: Mandatory for EU and many other jurisdictions

Business Applications

• Statistical reporting: Balance of payments statistics compilation
• Regulatory compliance: Meeting central bank reporting requirements
• Economic analysis: Supporting macroeconomic policy decisions
• Risk management: Transaction categorization for risk assessment
• Audit trails: Enhanced transaction tracking and classification
• Automated processing: STP routing based on transaction type

Regulatory Framework

Field 26T supports compliance with various regulatory requirements:

European Union

• ECB Regulation: European Central Bank balance of payments reporting
• EUROSTAT methodology: Statistical classification standards
• National implementations: Country-specific BoP reporting requirements

International Standards

• IMF BPM6: International Monetary Fund Balance of Payments Manual
• OECD guidelines: Organisation for Economic Co-operation and Development
• BIS reporting: Bank for International Settlements requirements

Validation Rules

1. Length: Must be exactly 3 characters
2. Character set: Only alphanumeric characters (A-Z, 0-9)
3. Case: Automatically normalized to uppercase
4. Format compliance: Must follow EUROSTAT BoP code structure
5. Non-empty: Cannot be empty or whitespace only

Network Validated Rules (SWIFT Standards)

• Transaction type code must be exactly 3 characters (Error: T26)
• Must contain only alphanumeric characters (Error: T61)
• Should follow recognized BoP classification (Warning: recommended practice)
• Must be consistent with transaction nature (Error: T40)

Examples

:26T:A01
└─── General merchandise trade

:26T:C02
└─── Investment income (dividends, interest)

:26T:F01
└─── Foreign direct investment

:26T:D02
└─── Private transfers/remittances

Fields

transaction_type_code: String

Transaction type code (exactly 3 alphanumeric characters)

Specifies the transaction type according to EUROSTAT Balance of Payments guidelines for statistical reporting and regulatory compliance.

Format: Exactly 3 uppercase alphanumeric characters Character set: A-Z, 0-9 only Case handling: Automatically converted to uppercase

Standard Categories

• A-series: Goods (A01, A02, A03)
• B-series: Services (B01, B02, B03)
• C-series: Primary Income (C01, C02)
• D-series: Secondary Income (D01, D02)
• E-series: Capital Account (E01, E02)
• F-series: Financial Account (F01-F05)

Examples

• "A01" - General merchandise on a gross basis
• "C02" - Investment income
• "F01" - Direct investment
• "D02" - Other sectors transfers

Implementations

impl Field26T

pub fn new(transaction_type_code: impl Into<String>) -> Result<Self>

Create a new Field26T with validation

pub fn code(&self) -> &str

Get the transaction type code

Returns the 3-character transaction type code that specifies the nature of the transaction for BoP classification.

Returns

A string slice containing the transaction type code in uppercase

Example

let field = Field26T::new("A01").unwrap();
assert_eq!(field.code(), "A01");

pub fn is_valid_format(&self) -> bool

Check if this is a valid EUROSTAT BoP code format

Validates that the code follows the basic format requirements for EUROSTAT Balance of Payments classification.

Returns

true if the code format is valid

Example

let field = Field26T::new("A01").unwrap();
assert!(field.is_valid_format());

pub fn bop_category(&self) -> &'static str

Get the BoP category for this transaction type

Returns the main Balance of Payments category that this transaction type belongs to.

Returns

BoP category as a string

Example

let field = Field26T::new("A01").unwrap();
assert_eq!(field.bop_category(), "Goods");

pub fn is_goods_transaction(&self) -> bool

Check if this is a goods transaction

Determines if the transaction type represents trade in goods according to BoP classification.

Returns

true if this is a goods transaction (A-series)

Example

let goods = Field26T::new("A01").unwrap();
assert!(goods.is_goods_transaction());

let service = Field26T::new("B01").unwrap();
assert!(!service.is_goods_transaction());

pub fn is_services_transaction(&self) -> bool

Check if this is a services transaction

Determines if the transaction type represents trade in services according to BoP classification.

Returns

true if this is a services transaction (B-series)

Example

let service = Field26T::new("B03").unwrap();
assert!(service.is_services_transaction());

pub fn is_income_transaction(&self) -> bool

Check if this is an income transaction

Determines if the transaction type represents income flows (primary or secondary income) according to BoP classification.

Returns

true if this is an income transaction (C or D series)

Example

let income = Field26T::new("C02").unwrap();
assert!(income.is_income_transaction());

let transfer = Field26T::new("D02").unwrap();
assert!(transfer.is_income_transaction());

pub fn is_financial_transaction(&self) -> bool

Check if this is a financial transaction

Determines if the transaction type represents financial flows according to BoP classification.

Returns

true if this is a financial transaction (F-series)

Example

let financial = Field26T::new("F01").unwrap();
assert!(financial.is_financial_transaction());

pub fn is_capital_transaction(&self) -> bool

Check if this is a capital account transaction

Determines if the transaction type represents capital account flows according to BoP classification.

Returns

true if this is a capital account transaction (E-series)

Example

let capital = Field26T::new("E01").unwrap();
assert!(capital.is_capital_transaction());

pub fn requires_enhanced_reporting(&self) -> bool

Check if this transaction requires enhanced reporting

Determines if the transaction type typically requires additional documentation or enhanced reporting for regulatory purposes.

Returns

true if enhanced reporting is typically required

Example

let investment = Field26T::new("F01").unwrap();
assert!(investment.requires_enhanced_reporting());

pub fn reporting_priority(&self) -> u8

Get the reporting priority level

Returns the priority level for statistical reporting based on the transaction type. Higher numbers indicate higher priority.

Returns

Priority level (1=low, 2=normal, 3=high, 4=critical)

Example

let reserves = Field26T::new("F05").unwrap();
assert_eq!(reserves.reporting_priority(), 4);

pub fn description(&self) -> &'static str

Get human-readable description based on common EUROSTAT BoP codes

Returns a detailed description of what this transaction type represents in the context of Balance of Payments classification.

Returns

A descriptive string

Example

let field = Field26T::new("A01").unwrap();
println!("{}", field.description());

pub fn statistical_significance(&self) -> &'static str

Get the statistical significance level

Returns the statistical significance of this transaction type for macroeconomic analysis and policy making.

Returns

Significance level description

Example

let field = Field26T::new("F01").unwrap();
assert_eq!(field.statistical_significance(), "High - Key economic indicator");

pub fn is_well_formed(&self) -> bool

Check if this code is well-formed according to BoP standards

Performs additional validation beyond basic format checking, ensuring the code follows EUROSTAT BoP classification principles.

Returns

true if the code is well-formed

Example

let good_code = Field26T::new("A01").unwrap();
assert!(good_code.is_well_formed());

let unknown_code = Field26T::new("Z99").unwrap();
assert!(!unknown_code.is_well_formed());

pub fn comprehensive_description(&self) -> String

Get comprehensive transaction details

Returns a detailed description including the transaction type code, BoP category, description, and statistical significance.

Returns

Formatted string with comprehensive details

Example

let field = Field26T::new("F01").unwrap();
println!("{}", field.comprehensive_description());

Trait Implementations

impl Clone for Field26T

fn clone(&self) -> Field26T

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Field26T

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Field26T

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Field26T

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

Formats the value using the given formatter.

impl PartialEq for Field26T

fn eq(&self, other: &Field26T) -> 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 Field26T

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 Field26T

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

Parse field value from string representation

fn to_swift_string(&self) -> String

Convert field back to SWIFT string format

fn validate(&self) -> ValidationResult

Validate field according to SWIFT format rules

fn format_spec() -> &'static str

Get field format specification

impl StructuralPartialEq for Field26T