diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2bb1fa4..033eae0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -270,7 +270,7 @@ jobs:
         uses: actions/checkout@v4
 
       - name: Run k6 Load Test
-        uses: grafana/k6-action@v0.5.0
+        uses: grafana/k6-action@v0.5.1
         with:
           filename: load-tests/run.js
           flags: --env SCENARIO=subscription
diff --git a/app/screens/DisputeManagementScreen.tsx b/app/screens/DisputeManagementScreen.tsx
new file mode 100644
index 0000000..733cd5c
--- /dev/null
+++ b/app/screens/DisputeManagementScreen.tsx
@@ -0,0 +1 @@
+export { default } from '../../src/screens/DisputeManagementScreen';
\ No newline at end of file
diff --git a/contracts/dispute/Cargo.toml b/contracts/dispute/Cargo.toml
new file mode 100644
index 0000000..9768147
--- /dev/null
+++ b/contracts/dispute/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "subtrackr-dispute"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+soroban-sdk = { workspace = true }
+subtrackr-types = { path = "../types" }
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[profile.release]
+opt-level = "z"
+lto = true
+codegen-units = 1
\ No newline at end of file
diff --git a/contracts/dispute/src/lib.rs b/contracts/dispute/src/lib.rs
new file mode 100644
index 0000000..8259bae
--- /dev/null
+++ b/contracts/dispute/src/lib.rs
@@ -0,0 +1,808 @@
+// ════════════════════════════════════════════════════════════════
+// DISPUTE RESOLUTION SYSTEM - Handle chargebacks and payment disputes
+// ════════════════════════════════════════════════════════════════
+
+#![no_std]
+
+use soroban_sdk::{
+    contract, contractimpl, contracttype, Address, BytesN, Env, IntoVal, String, Symbol, TryFromVal,
+    Val, Vec,
+};
+
+// ════════════════════════════════════════════════════════════════
+// DATA STRUCTURES
+// ════════════════════════════════════════════════════════════════
+
+#[derive(Clone)]
+#[contracttype]
+enum DataKey {
+    AdminOwners,
+    AdminThreshold,
+    AdminTimelockDelaySeconds,
+    AdminProposalSeq,
+    AdminProposal,
+    ContractVersion,
+    // Dispute-specific keys
+    Dispute(DisputeId),
+    DisputeCount,
+    DisputeByCharge(ChargeId),
+    DisputeTimeline(DisputeId),
+    DisputeEvidence(DisputeId),
+    DisputeAnalytics,
+}
+
+/// Unique identifier for a dispute
+#[derive(Clone)]
+#[contracttype]
+pub struct DisputeId {
+    pub inner: u64,
+}
+
+/// Charge identifier from payment system
+#[derive(Clone)]
+#[contracttype]
+pub struct ChargeId {
+    pub inner: String,
+}
+
+impl DisputeId {
+    pub fn new(env: &Env, value: u64) -> Self {
+        DisputeId { inner: value }
+    }
+
+    pub fn to_val(&self) -> Val {
+        self.inner.into_val(&Env::new())
+    }
+}
+
+impl ChargeId {
+    pub fn new(env: &Env, value: &str) -> Self {
+        ChargeId {
+            inner: String::from_str(env, value),
+        }
+    }
+}
+
+/// Dispute status enum
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[contracttype]
+pub enum DisputeStatus {
+    /// Dispute has been created but not yet submitted
+    Pending = 0,
+    /// Evidence is being collected
+    GatheringEvidence = 1,
+    /// Evidence submitted, awaiting review
+    UnderReview = 2,
+    /// Awaiting manual review decision
+    AwaitingManualReview = 3,
+    /// Dispute has been resolved
+    Resolved = 4,
+    /// Dispute was rejected
+    Rejected = 5,
+    /// Dispute expired due to time limit
+    Expired = 6,
+}
+
+/// Dispute resolution outcome
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[contracttype]
+pub enum Resolution {
+    /// Dispute won - customer gets refund
+    Refund = 0,
+    /// Original charge upheld - no refund
+    Upheld = 1,
+    /// Partial refund granted
+    PartialRefund = 2,
+    /// Counter-claim successful
+    Counter = 3,
+    /// Settlement reached between parties
+    Settlement = 4,
+}
+
+/// Evidence type for dispute
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[contracttype]
+pub enum EvidenceType {
+    /// Proof of delivery
+    ProofOfDelivery = 0,
+    /// Communication records
+    Communication = 1,
+    /// Contract/terms documentation
+    Contract = 2,
+    /// Receipt or invoice
+    Receipt = 3,
+    /// Product/service description
+    ProductDescription = 4,
+    /// Customer interaction history
+    InteractionHistory = 5,
+    /// Other evidence
+    Other = 6,
+}
+
+/// Evidence submitted for dispute
+#[derive(Clone)]
+#[contracttype]
+pub struct Evidence {
+    /// Type of evidence
+    pub evidence_type: EvidenceType,
+    /// Description of the evidence
+    pub description: String,
+    /// URL or reference to evidence file
+    pub reference: String,
+    /// Timestamp when evidence was submitted
+    pub submitted_at: u64,
+    /// Who submitted the evidence
+    pub submitted_by: Address,
+}
+
+/// Timeline event for dispute
+#[derive(Clone)]
+#[contracttype]
+pub struct TimelineEvent {
+    /// Event type
+    pub event_type: TimelineEventType,
+    /// Description of the event
+    pub description: String,
+    /// Timestamp of the event
+    pub timestamp: u64,
+    /// Who triggered the event
+    pub triggered_by: Address,
+}
+
+/// Timeline event types
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[contracttype]
+pub enum TimelineEventType {
+    Created = 0,
+    EvidenceSubmitted = 1,
+    StatusChanged = 2,
+    ManualReviewRequested = 3,
+    Resolved = 4,
+    Expired = 5,
+}
+
+/// Main dispute struct
+#[derive(Clone)]
+#[contracttype]
+pub struct Dispute {
+    /// Unique dispute identifier
+    pub dispute_id: DisputeId,
+    /// Charge ID this dispute is related to
+    pub charge_id: ChargeId,
+    /// Subscription ID (if applicable)
+    pub subscription_id: Option<String>,
+    /// User who created the dispute
+    pub user: Address,
+    /// Reason for the dispute
+    pub reason: DisputeReason,
+    /// Current status of the dispute
+    pub status: DisputeStatus,
+    /// Evidence submitted for this dispute
+    pub evidence: Vec<Evidence>,
+    /// Resolution (if resolved)
+    pub resolution: Option<Resolution>,
+    /// Resolution notes
+    pub resolution_notes: Option<String>,
+    /// When the dispute was created
+    pub created_at: u64,
+    /// When the dispute was last updated
+    pub updated_at: u64,
+    /// Deadline for submitting evidence
+    pub evidence_deadline: u64,
+    /// Resolution timestamp (if resolved)
+    pub resolved_at: Option<u64>,
+}
+
+/// Dispute reasons
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[contracttype]
+pub enum DisputeReason {
+    /// Product/service not as described
+    NotAsDescribed = 0,
+    /// Product/service not received
+    NotReceived = 0,
+    /// Unauthorized charge
+    Unauthorized = 1,
+    /// Duplicate charge
+    Duplicate = 2,
+    /// Incorrect amount charged
+    IncorrectAmount = 3,
+    /// Subscription cancelled but charged
+    CancelledSubscription = 4,
+    /// Refund not processed
+    RefundNotProcessed = 5,
+    /// Other reason
+    Other = 6,
+}
+
+/// Dispute analytics data
+#[derive(Clone)]
+#[contracttype]
+pub struct DisputeAnalytics {
+    /// Total disputes filed
+    pub total_disputes: u64,
+    /// Disputes won (refund)
+    pub disputes_won: u64,
+    /// Disputes lost (upheld)
+    pub disputes_lost: u64,
+    /// Disputes settled
+    pub disputes_settled: u64,
+    /// Pending disputes
+    pub pending_disputes: u64,
+    /// Average resolution time in seconds
+    pub avg_resolution_time: u64,
+    /// Total amount disputed
+    pub total_amount_disputed: u64,
+    /// Total amount refunded
+    pub total_amount_refunded: u64,
+}
+
+/// Admin action for dispute management
+#[derive(Clone)]
+#[contracttype]
+pub enum AdminAction {
+    AddOwner(Address),
+    RemoveOwner(Address),
+    SetThreshold(u32),
+    SetTimelockDelaySeconds(u64),
+}
+
+/// Admin proposal for dispute review
+#[derive(Clone)]
+#[contracttype]
+pub struct AdminProposal {
+    pub id: u64,
+    pub action: AdminAction,
+    pub created_at: u64,
+    pub execute_after: u64,
+    pub approvals: Vec<Address>,
+}
+
+// ════════════════════════════════════════════════════════════════
+// CONSTANTS
+// ════════════════════════════════════════════════════════════════
+
+/// Default evidence submission deadline (7 days in seconds)
+const DEFAULT_EVIDENCE_DEADLINE_SECS: u64 = 604800;
+
+/// Maximum evidence items per dispute
+const MAX_EVIDENCE_PER_DISPUTE: u32 = 20;
+
+/// Dispute analytics storage key
+struct DisputeAnalyticsKey;
+
+// ════════════════════════════════════════════════════════════════
+// CONTRACT IMPLEMENTATION
+// ════════════════════════════════════════════════════════════════
+
+#[contract]
+pub struct SubTrackrDispute;
+
+#[contractimpl]
+impl SubTrackrDispute {
+    /// Initialize the dispute contract with an admin.
+    pub fn init(env: Env, admin: Address) {
+        if env.storage().instance().has(&DataKey::AdminOwners) {
+            panic!("already initialized");
+        }
+
+        admin.require_auth();
+        let mut owners: Vec<Address> = Vec::new(&env);
+        owners.push_back(admin.clone());
+        env.storage().instance().set(&DataKey::AdminOwners, &owners);
+        env.storage().instance().set(&DataKey::AdminThreshold, &1u32);
+        env.storage()
+            .instance()
+            .set(&DataKey::AdminTimelockDelaySeconds, &0u64);
+        env.storage().instance().set(&DataKey::AdminProposalSeq, &0u64);
+        env.storage().instance().set(&DataKey::ContractVersion, &1u32);
+
+        // Initialize dispute analytics
+        let analytics = DisputeAnalytics {
+            total_disputes: 0,
+            disputes_won: 0,
+            disputes_lost: 0,
+            disputes_settled: 0,
+            pending_disputes: 0,
+            avg_resolution_time: 0,
+            total_amount_disputed: 0,
+            total_amount_refunded: 0,
+        };
+        env.storage()
+            .instance()
+            .set(&DataKey::DisputeAnalytics, &analytics);
+
+        env.events()
+            .publish(Symbol::new(&env, "dispute_contract_initialized"), admin);
+    }
+
+    /// Create a new dispute from a chargeback notification.
+    ///
+    /// # Arguments
+    /// * `env` - Soroban environment
+    /// * `charge_id` - The charge ID to dispute
+    /// * `reason` - The reason for the dispute
+    /// * `subscription_id` - Optional subscription ID
+    /// * `user` - The user creating the dispute
+    ///
+    /// # Returns
+    /// * `DisputeId` - The created dispute's ID
+    pub fn create_dispute(
+        env: Env,
+        charge_id: String,
+        reason: DisputeReason,
+        subscription_id: Option<String>,
+        user: Address,
+    ) -> DisputeId {
+        user.require_auth();
+
+        // Generate dispute ID
+        let mut count: u64 = env
+            .storage()
+            .instance()
+            .get(&DataKey::DisputeCount)
+            .unwrap_or(0);
+        count += 1;
+        let dispute_id = DisputeId::new(&env, count);
+
+        // Store dispute count
+        env.storage()
+            .instance()
+            .set(&DataKey::DisputeCount, &count);
+
+        // Create charge ID
+        let charge = ChargeId::new(&env, &charge_id);
+
+        // Calculate evidence deadline (7 days from now)
+        let now = env.ledger().timestamp();
+        let evidence_deadline = now + DEFAULT_EVIDENCE_DEADLINE_SECS;
+
+        // Create the dispute
+        let dispute = Dispute {
+            dispute_id: dispute_id.clone(),
+            charge_id: charge,
+            subscription_id: subscription_id.clone(),
+            user: user.clone(),
+            reason,
+            status: DisputeStatus::Pending,
+            evidence: Vec::new(&env),
+            resolution: None,
+            resolution_notes: None,
+            created_at: now,
+            updated_at: now,
+            evidence_deadline,
+            resolved_at: None,
+        };
+
+        // Store the dispute
+        env.storage()
+            .instance()
+            .set(&DataKey::Dispute(dispute_id.clone()), &dispute);
+
+        // Index by charge ID
+        env.storage()
+            .instance()
+            .set(&DataKey::DisputeByCharge(charge), &dispute_id);
+
+        // Initialize timeline
+        let mut timeline: Vec<TimelineEvent> = Vec::new(&env);
+        timeline.push_back(TimelineEvent {
+            event_type: TimelineEventType::Created,
+            description: String::from_str(&env, "Dispute created"),
+            timestamp: now,
+            triggered_by: user,
+        });
+        env.storage()
+            .instance()
+            .set(&DataKey::DisputeTimeline(dispute_id.clone()), &timeline);
+
+        // Update analytics
+        Self::update_analytics(&env, true, 0, 0);
+
+        // Emit event
+        env.events().publish(
+            Symbol::new(&env, "dispute_created"),
+            (dispute_id.clone(), charge_id, reason),
+        );
+
+        dispute_id
+    }
+
+    /// Submit evidence for a dispute.
+    ///
+    /// # Arguments
+    /// * `env` - Soroban environment
+    /// * `dispute_id` - The dispute ID
+    /// * `evidence_type` - Type of evidence
+    /// * `description` - Evidence description
+    /// * `reference` - Evidence reference/URL
+    /// * `submitter` - Who is submitting the evidence
+    pub fn submit_evidence(
+        env: Env,
+        dispute_id: DisputeId,
+        evidence_type: EvidenceType,
+        description: String,
+        reference: String,
+        submitter: Address,
+    ) -> Result<(), String> {
+        submitter.require_auth();
+
+        // Get the dispute
+        let key = DataKey::Dispute(dispute_id.clone());
+        let mut dispute: Dispute = env
+            .storage()
+            .instance()
+            .get(&key)
+            .ok_or("Dispute not found")?;
+
+        // Check if dispute is still active
+        if dispute.status == DisputeStatus::Resolved
+            || dispute.status == DisputeStatus::Rejected
+            || dispute.status == DisputeStatus::Expired
+        {
+            return Err(String::from_str(&env, "Cannot submit evidence to resolved dispute"));
+        }
+
+        // Check evidence deadline
+        let now = env.ledger().timestamp();
+        if now > dispute.evidence_deadline {
+            // Mark as expired
+            dispute.status = DisputeStatus::Expired;
+            dispute.updated_at = now;
+            env.storage().instance().set(&key, &dispute);
+            return Err(String::from_str(&env, "Evidence submission deadline passed"));
+        }
+
+        // Check max evidence limit
+        if dispute.evidence.len() >= MAX_EVIDENCE_PER_DISPUTE {
+            return Err(String::from_str(&env, "Maximum evidence limit reached"));
+        }
+
+        // Create evidence
+        let evidence = Evidence {
+            evidence_type,
+            description,
+            reference,
+            submitted_at: now,
+            submitted_by: submitter.clone(),
+        };
+
+        // Add evidence to dispute
+        dispute.evidence.push_back(evidence);
+        dispute.status = DisputeStatus::GatheringEvidence;
+        dispute.updated_at = now;
+
+        // Store updated dispute
+        env.storage().instance().set(&key, &dispute);
+
+        // Update timeline
+        let timeline_key = DataKey::DisputeTimeline(dispute_id.clone());
+        let mut timeline: Vec<TimelineEvent> = env
+            .storage()
+            .instance()
+            .get(&timeline_key)
+            .unwrap_or(Vec::new(&env));
+
+        timeline.push_back(TimelineEvent {
+            event_type: TimelineEventType::EvidenceSubmitted,
+            description: String::from_str(&env, "Evidence submitted"),
+            timestamp: now,
+            triggered_by: submitter,
+        });
+        env.storage()
+            .instance()
+            .set(&timeline_key, &timeline);
+
+        // Emit event
+        env.events().publish(
+            Symbol::new(&env, "evidence_submitted"),
+            (dispute_id, evidence_type),
+        );
+
+        Ok(())
+    }
+
+    /// Request manual review for a dispute.
+    ///
+    /// # Arguments
+    /// * `env` - Soroban environment
+    /// * `dispute_id` - The dispute ID
+    /// * `requester` - Who is requesting the review
+    pub fn request_manual_review(
+        env: Env,
+        dispute_id: DisputeId,
+        requester: Address,
+    ) -> Result<(), String> {
+        requester.require_auth();
+
+        // Get the dispute
+        let key = DataKey::Dispute(dispute_id.clone());
+        let mut dispute: Dispute = env
+            .storage()
+            .instance()
+            .get(&key)
+            .ok_or("Dispute not found")?;
+
+        // Check if dispute can be reviewed
+        if dispute.status == DisputeStatus::Resolved
+            || dispute.status == DisputeStatus::Rejected
+            || dispute.status == DisputeStatus::Expired
+        {
+            return Err(String::from_str(&env, "Cannot request review for resolved dispute"));
+        }
+
+        // Update status
+        dispute.status = DisputeStatus::AwaitingManualReview;
+        dispute.updated_at = env.ledger().timestamp();
+
+        // Store updated dispute
+        env.storage().instance().set(&key, &dispute);
+
+        // Update timeline
+        let timeline_key = DataKey::DisputeTimeline(dispute_id.clone());
+        let mut timeline: Vec<TimelineEvent> = env
+            .storage()
+            .instance()
+            .get(&timeline_key)
+            .unwrap_or(Vec::new(&env));
+
+        timeline.push_back(TimelineEvent {
+            event_type: TimelineEventType::ManualReviewRequested,
+            description: String::from_str(&env, "Manual review requested"),
+            timestamp: env.ledger().timestamp(),
+            triggered_by: requester,
+        });
+        env.storage()
+            .instance()
+            .set(&timeline_key, &timeline);
+
+        // Emit event
+        env.events().publish(
+            Symbol::new(&env, "manual_review_requested"),
+            dispute_id,
+        );
+
+        Ok(())
+    }
+
+    /// Resolve a dispute with the given resolution.
+    ///
+    /// # Arguments
+    /// * `env` - Soroban environment
+    /// * `dispute_id` - The dispute ID
+    /// * `resolution` - The resolution outcome
+    /// * `resolution_notes` - Notes about the resolution
+    /// * `resolver` - Who is resolving the dispute
+    pub fn resolve_dispute(
+        env: Env,
+        dispute_id: DisputeId,
+        resolution: Resolution,
+        resolution_notes: Option<String>,
+        resolver: Address,
+    ) -> Result<(), String> {
+        // Get the dispute
+        let key = DataKey::Dispute(dispute_id.clone());
+        let mut dispute: Dispute = env
+            .storage()
+            .instance()
+            .get(&key)
+            .ok_or("Dispute not found")?;
+
+        // Check if dispute can be resolved
+        if dispute.status == DisputeStatus::Resolved
+            || dispute.status == DisputeStatus::Rejected
+            || dispute.status == DisputeStatus::Expired
+        {
+            return Err(String::from_str(&env, "Dispute already resolved"));
+        }
+
+        let now = env.ledger().timestamp();
+
+        // Update dispute
+        dispute.status = DisputeStatus::Resolved;
+        dispute.resolution = Some(resolution);
+        dispute.resolution_notes = resolution_notes;
+        dispute.updated_at = now;
+        dispute.resolved_at = Some(now);
+
+        // Store updated dispute
+        env.storage().instance().set(&key, &dispute);
+
+        // Update timeline
+        let timeline_key = DataKey::DisputeTimeline(dispute_id.clone());
+        let mut timeline: Vec<TimelineEvent> = env
+            .storage()
+            .instance()
+            .get(&timeline_key)
+            .unwrap_or(Vec::new(&env));
+
+        timeline.push_back(TimelineEvent {
+            event_type: TimelineEventType::Resolved,
+            description: String::from_str(&env, "Dispute resolved"),
+            timestamp: now,
+            triggered_by: resolver,
+        });
+        env.storage()
+            .instance()
+            .set(&timeline_key, &timeline);
+
+        // Update analytics based on resolution
+        let (won, lost, settled) = match resolution {
+            Resolution::Refund => (true, false, false),
+            Resolution::Upheld => (false, true, false),
+            Resolution::PartialRefund => (true, false, true),
+            Resolution::Counter => (true, false, false),
+            Resolution::Settlement => (false, false, true),
+        };
+
+        Self::update_analytics(&env, false, won, settled);
+
+        // Emit event
+        env.events().publish(
+            Symbol::new(&env, "dispute_resolved"),
+            (dispute_id, resolution),
+        );
+
+        Ok(())
+    }
+
+    /// Get a dispute by ID.
+    pub fn get_dispute(env: Env, dispute_id: DisputeId) -> Option<Dispute> {
+        env.storage()
+            .instance()
+            .get(&DataKey::Dispute(dispute_id))
+    }
+
+    /// Get dispute by charge ID.
+    pub fn get_dispute_by_charge(env: Env, charge_id: String) -> Option<DisputeId> {
+        let charge = ChargeId::new(&env, &charge_id);
+        env.storage()
+            .instance()
+            .get(&DataKey::DisputeByCharge(charge))
+    }
+
+    /// Get dispute timeline.
+    pub fn get_timeline(env: Env, dispute_id: DisputeId) -> Vec<TimelineEvent> {
+        env.storage()
+            .instance()
+            .get(&DataKey::DisputeTimeline(dispute_id))
+            .unwrap_or(Vec::new(&env))
+    }
+
+    /// Get dispute evidence.
+    pub fn get_evidence(env: Env, dispute_id: DisputeId) -> Vec<Evidence> {
+        let dispute: Option<Dispute> = env
+            .storage()
+            .instance()
+            .get(&DataKey::Dispute(dispute_id));
+        dispute.map(|d| d.evidence).unwrap_or(Vec::new(&env))
+    }
+
+    /// Get all disputes for a user.
+    pub fn get_user_disputes(env: Env, user: Address) -> Vec<Dispute> {
+        // This would require iterating through all disputes
+        // In production, you'd want an index by user
+        Vec::new(&env)
+    }
+
+    /// Get dispute analytics.
+    pub fn get_analytics(env: Env) -> DisputeAnalytics {
+        env.storage()
+            .instance()
+            .get(&DataKey::DisputeAnalytics)
+            .unwrap_or(DisputeAnalytics {
+                total_disputes: 0,
+                disputes_won: 0,
+                disputes_lost: 0,
+                disputes_settled: 0,
+                pending_disputes: 0,
+                avg_resolution_time: 0,
+                total_amount_disputed: 0,
+                total_amount_refunded: 0,
+            })
+    }
+
+    /// Check and update expired disputes.
+    pub fn check_expired_disputes(env: Env) -> u32 {
+        let count: u64 = env
+            .storage()
+            .instance()
+            .get(&DataKey::DisputeCount)
+            .unwrap_or(0);
+
+        let mut expired_count = 0;
+        let now = env.ledger().timestamp();
+
+        for i in 1..=count {
+            let dispute_id = DisputeId::new(&env, i);
+            let key = DataKey::Dispute(dispute_id.clone());
+
+            if let Some(mut dispute) = env.storage().instance().get::<_, Dispute>(&key) {
+                if dispute.status != DisputeStatus::Resolved
+                    && dispute.status != DisputeStatus::Rejected
+                    && dispute.status != DisputeStatus::Expired
+                    && now > dispute.evidence_deadline
+                {
+                    dispute.status = DisputeStatus::Expired;
+                    dispute.updated_at = now;
+                    env.storage().instance().set(&key, &dispute);
+                    expired_count += 1;
+                }
+            }
+        }
+
+        // Update analytics
+        Self::update_analytics(&env, false, false, false);
+
+        expired_count
+    }
+
+    /// Update dispute analytics.
+    fn update_analytics(env: &Env, new_dispute: bool, won: bool, settled: bool) {
+        let mut analytics: DisputeAnalytics = env
+            .storage()
+            .instance()
+            .get(&DataKey::DisputeAnalytics)
+            .unwrap_or(DisputeAnalytics {
+                total_disputes: 0,
+                disputes_won: 0,
+                disputes_lost: 0,
+                disputes_settled: 0,
+                pending_disputes: 0,
+                avg_resolution_time: 0,
+                total_amount_disputed: 0,
+                total_amount_refunded: 0,
+            });
+
+        if new_dispute {
+            analytics.total_disputes += 1;
+            analytics.pending_disputes += 1;
+        } else {
+            // Count pending
+            let count: u64 = env
+                .storage()
+                .instance()
+                .get(&DataKey::DisputeCount)
+                .unwrap_or(0);
+
+            let mut pending = 0u64;
+            for i in 1..=count {
+                let dispute_id = DisputeId::new(env, i);
+                let key = DataKey::Dispute(dispute_id);
+
+                if let Some(dispute) = env.storage().instance().get::<_, Dispute>(&key) {
+                    if dispute.status != DisputeStatus::Resolved
+                        && dispute.status != DisputeStatus::Rejected
+                        && dispute.status != DisputeStatus::Expired
+                    {
+                        pending += 1;
+                    }
+                }
+            }
+            analytics.pending_disputes = pending;
+
+            if won {
+                analytics.disputes_won += 1;
+            }
+            if settled {
+                analytics.disputes_settled += 1;
+            }
+            if !won && !settled && analytics.pending_disputes == 0 {
+                // Must have been lost
+                analytics.disputes_lost += 1;
+            }
+        }
+
+        env.storage()
+            .instance()
+            .set(&DataKey::DisputeAnalytics, &analytics);
+    }
+
+    /// Get dispute count.
+    pub fn get_dispute_count(env: Env) -> u64 {
+        env.storage()
+            .instance()
+            .get(&DataKey::DisputeCount)
+            .unwrap_or(0)
+    }
+}
\ No newline at end of file
diff --git a/src/navigation/AppNavigator.tsx b/src/navigation/AppNavigator.tsx
index d1850e1..ae9aec9 100644
--- a/src/navigation/AppNavigator.tsx
+++ b/src/navigation/AppNavigator.tsx
@@ -21,6 +21,8 @@ import SettingsScreen from '../screens/SettingsScreen';
 import AccountingExportScreen from '../screens/AccountingExportScreen';
 import WebhookSettingsScreen from '../screens/WebhookSettingsScreen';
 import ErrorDashboardScreen from '../screens/ErrorDashboardScreen';
+import ImportScreen from '../screens/ImportScreen';
+import ExportScreen from '../screens/ExportScreen';
 import AdminDashboardScreen from '../screens/AdminDashboardScreen';
 import InvoiceListScreen from '../screens/InvoiceListScreen';
 import InvoiceDetailScreen from '../screens/InvoiceDetailScreen';
@@ -160,6 +162,61 @@ const SettingsStack = () => (
       component={ErrorDashboardScreen}
       options={{ title: 'Error Dashboard', headerShown: true }}
     />
+    <Stack.Screen 
+      name="Import" 
+      component={ImportScreen} 
+      options={{ title: 'Import Subscriptions', headerShown: true }} 
+    />
+    <Stack.Screen 
+      name="Export" 
+      component={ExportScreen} 
+      options={{ title: 'Export Subscriptions', headerShown: true }} 
+    />
+    <Stack.Screen
+      name="Profile"
+      component={ProfileScreen}
+      options={{ title: 'Profile', headerShown: true }}
+    />
+    <Stack.Screen
+      name="GDPRSettings"
+      component={GDPRSettingsScreen}
+      options={{ title: 'Privacy Settings', headerShown: true }}
+    />
+    <Stack.Screen
+      name="LanguageSettings"
+      component={LanguageSettingsScreen}
+      options={{ title: 'Language', headerShown: true }}
+    />
+    <Stack.Screen
+      name="SessionManagement"
+      component={SessionManagementScreen}
+      options={{ title: 'Sessions', headerShown: true }}
+    />
+    <Stack.Screen
+      name="AdminDashboard"
+      component={AdminDashboardScreen}
+      options={{ title: 'Admin Dashboard', headerShown: true }}
+    />
+    <Stack.Screen
+      name="WebhookSettings"
+      component={WebhookSettingsScreen}
+      options={{ title: 'Webhooks', headerShown: true }}
+    />
+    <Stack.Screen
+      name="AccountingExport"
+      component={AccountingExportScreen}
+      options={{ title: 'Accounting Export', headerShown: true }}
+    />
+    <Stack.Screen
+      name="SlaDashboard"
+      component={SlaDashboard}
+      options={{ title: 'SLA Dashboard', headerShown: true }}
+    />
+    <Stack.Screen
+      name="ErrorDashboard"
+      component={ErrorDashboardScreen}
+      options={{ title: 'Error Dashboard', headerShown: true }}
+    />
   </Stack.Navigator>
 );
 
diff --git a/src/navigation/types.ts b/src/navigation/types.ts
index 194cc44..a75efed 100644
--- a/src/navigation/types.ts
+++ b/src/navigation/types.ts
@@ -20,6 +20,8 @@ export type RootStackParamList = {
   LanguageSettings: undefined;
   SessionManagement: undefined;
   ErrorDashboard: undefined;
+  Import: undefined;
+  Export: undefined;
   SegmentManagement: undefined;
   SegmentDetail: { segmentId: string };
   Gamification: undefined;
diff --git a/src/screens/DisputeManagementScreen.tsx b/src/screens/DisputeManagementScreen.tsx
new file mode 100644
index 0000000..f70e48b
--- /dev/null
+++ b/src/screens/DisputeManagementScreen.tsx
@@ -0,0 +1,1240 @@
+import React, { useEffect, useMemo, useState } from 'react';
+import {
+  View,
+  Text,
+  StyleSheet,
+  ScrollView,
+  SafeAreaView,
+  RefreshControl,
+  TouchableOpacity,
+  Modal,
+  TextInput,
+  Alert,
+  FlatList,
+  ActivityIndicator,
+} from 'react-native';
+import { useNavigation } from '@react-navigation/native';
+import { NativeStackNavigationProp } from '@react-navigation/native-stack';
+
+import { colors, spacing, typography, borderRadius } from '../utils/constants';
+import { useDisputeStore, Dispute, DisputeStatus, DisputeReason, Resolution, EvidenceType, EvidenceFormData, DisputeAnalytics } from '../store/disputeStore';
+import { RootStackParamList } from '../navigation/types';
+
+type HomeNavigationProp = NativeStackNavigationProp<RootStackParamList>;
+
+// ════════════════════════════════════════════════════════════════
+// COMPONENTS
+// ════════════════════════════════════════════════════════════════
+
+/** Status badge component */
+const StatusBadge: React.FC<{ status: DisputeStatus }> = ({ status }) => {
+  const getStatusColor = () => {
+    switch (status) {
+      case DisputeStatus.Pending:
+        return colors.warning;
+      case DisputeStatus.GatheringEvidence:
+        return colors.info;
+      case DisputeStatus.UnderReview:
+        return colors.primary;
+      case DisputeStatus.AwaitingManualReview:
+        return colors.secondary;
+      case DisputeStatus.Resolved:
+        return colors.success;
+      case DisputeStatus.Rejected:
+        return colors.error;
+      case DisputeStatus.Expired:
+        return colors.muted;
+      default:
+        return colors.muted;
+    }
+  };
+
+  const getStatusLabel = () => {
+    return status.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+  };
+
+  return (
+    <View style={[styles.statusBadge, { backgroundColor: getStatusColor() + '20' }]}>
+      <Text style={[styles.statusBadgeText, { color: getStatusColor() }]}>
+        {getStatusLabel()}
+      </Text>
+    </View>
+  );
+};
+
+/** Reason badge component */
+const ReasonBadge: React.FC<{ reason: DisputeReason }> = ({ reason }) => {
+  const getReasonLabel = () => {
+    const labels: Record<DisputeReason, string> = {
+      [DisputeReason.NotAsDescribed]: 'Not as Described',
+      [DisputeReason.NotReceived]: 'Not Received',
+      [DisputeReason.Unauthorized]: 'Unauthorized',
+      [DisputeReason.Duplicate]: 'Duplicate',
+      [DisputeReason.IncorrectAmount]: 'Incorrect Amount',
+      [DisputeReason.CancelledSubscription]: 'Cancelled',
+      [DisputeReason.RefundNotProcessed]: 'Refund Missing',
+      [DisputeReason.Other]: 'Other',
+    };
+    return labels[reason] || reason;
+  };
+
+  return (
+    <View style={styles.reasonBadge}>
+      <Text style={styles.reasonBadgeText}>{getReasonLabel()}</Text>
+    </View>
+  );
+};
+
+/** Analytics card component */
+const AnalyticsCard: React.FC<{ analytics: DisputeAnalytics }> = ({ analytics }) => {
+  return (
+    <View style={styles.analyticsCard}>
+      <Text style={styles.analyticsTitle}>Dispute Analytics</Text>
+      <View style={styles.analyticsGrid}>
+        <View style={styles.analyticsItem}>
+          <Text style={styles.analyticsValue}>{analytics.totalDisputes}</Text>
+          <Text style={styles.analyticsLabel}>Total</Text>
+        </View>
+        <View style={styles.analyticsItem}>
+          <Text style={[styles.analyticsValue, { color: colors.warning }]}>
+            {analytics.pendingDisputes}
+          </Text>
+          <Text style={styles.analyticsLabel}>Pending</Text>
+        </View>
+        <View style={styles.analyticsItem}>
+          <Text style={[styles.analyticsValue, { color: colors.success }]}>
+            {analytics.disputesWon}
+          </Text>
+          <Text style={styles.analyticsLabel}>Won</Text>
+        </View>
+        <View style={styles.analyticsItem}>
+          <Text style={[styles.analyticsValue, { color: colors.error }]}>
+            {analytics.disputesLost}
+          </Text>
+          <Text style={styles.analyticsLabel}>Lost</Text>
+        </View>
+      </View>
+      <View style={styles.analyticsRow}>
+        <Text style={styles.analyticsText}>
+          Total Disputed: ${analytics.totalAmountDisputed.toFixed(2)}
+        </Text>
+        <Text style={styles.analyticsText}>
+          Refunded: ${analytics.totalAmountRefunded.toFixed(2)}
+        </Text>
+      </View>
+    </View>
+  );
+};
+
+/** Dispute item component */
+const DisputeItem: React.FC<{
+  dispute: Dispute;
+  onPress: (dispute: Dispute) => void;
+}> = ({ dispute, onPress }) => {
+  const formatDate = (date: Date) => {
+    return new Date(date).toLocaleDateString('en-US', {
+      month: 'short',
+      day: 'numeric',
+      year: 'numeric',
+    });
+  };
+
+  const getDaysRemaining = () => {
+    const now = new Date();
+    const deadline = new Date(dispute.evidenceDeadline);
+    const diff = deadline.getTime() - now.getTime();
+    return Math.ceil(diff / (1000 * 60 * 60 * 24));
+  };
+
+  const daysRemaining = getDaysRemaining();
+
+  return (
+    <TouchableOpacity
+      style={styles.disputeItem}
+      onPress={() => onPress(dispute)}
+      accessibilityRole="button"
+      accessibilityLabel={`Dispute for charge ${dispute.chargeId}`}>
+      <View style={styles.disputeItemHeader}>
+        <View style={styles.disputeItemInfo}>
+          <Text style={styles.disputeItemCharge} numberOfLines={1}>
+            {dispute.chargeId}
+          </Text>
+          <Text style={styles.disputeItemDate}>
+            Created: {formatDate(dispute.createdAt)}
+          </Text>
+        </View>
+        <View style={styles.disputeItemAmount}>
+          <Text style={styles.disputeItemAmountText}>
+            ${dispute.amount.toFixed(2)}
+          </Text>
+          <Text style={styles.disputeItemCurrency}>{dispute.currency}</Text>
+        </View>
+      </View>
+      <View style={styles.disputeItemBody}>
+        <ReasonBadge reason={dispute.reason} />
+        <StatusBadge status={dispute.status} />
+      </View>
+      {dispute.status !== DisputeStatus.Resolved &&
+        dispute.status !== DisputeStatus.Rejected &&
+        dispute.status !== DisputeStatus.Expired && (
+          <View style={styles.disputeItemFooter}>
+            <Text
+              style={[
+                styles.daysRemaining,
+                daysRemaining < 3 ? styles.daysRemainingUrgent : null,
+              ]}>
+              {daysRemaining > 0
+                ? `${daysRemaining} days to submit evidence`
+                : 'Evidence deadline passed'}
+            </Text>
+          </View>
+        )}
+    </TouchableOpacity>
+  );
+};
+
+/** Evidence form component */
+const EvidenceForm: React.FC<{
+  visible: boolean;
+  onClose: () => void;
+  onSubmit: (evidence: EvidenceFormData) => void;
+}> = ({ visible, onClose, onSubmit }) => {
+  const [evidenceType, setEvidenceType] = useState<EvidenceType>(EvidenceType.Receipt);
+  const [description, setDescription] = useState('');
+  const [reference, setReference] = useState('');
+
+  const handleSubmit = () => {
+    if (!description.trim()) {
+      Alert.alert('Error', 'Please provide a description');
+      return;
+    }
+
+    onSubmit({
+      evidenceType,
+      description: description.trim(),
+      reference: reference.trim(),
+    });
+
+    // Reset form
+    setEvidenceType(EvidenceType.Receipt);
+    setDescription('');
+    setReference('');
+    onClose();
+  };
+
+  return (
+    <Modal visible={visible} animationType="slide" presentationStyle="pageSheet">
+      <SafeAreaView style={styles.formModal}>
+        <View style={styles.formHeader}>
+          <TouchableOpacity onPress={onClose}>
+            <Text style={styles.formCancel}>Cancel</Text>
+          </TouchableOpacity>
+          <Text style={styles.formTitle}>Submit Evidence</Text>
+          <TouchableOpacity onPress={handleSubmit}>
+            <Text style={styles.formSubmit}>Submit</Text>
+          </TouchableOpacity>
+        </View>
+        <ScrollView style={styles.formContent}>
+          <Text style={styles.formLabel}>Evidence Type</Text>
+          <View style={styles.evidenceTypeGrid}>
+            {Object.values(EvidenceType).map((type) => (
+              <TouchableOpacity
+                key={type}
+                style={[
+                  styles.evidenceTypeButton,
+                  evidenceType === type && styles.evidenceTypeButtonSelected,
+                ]}
+                onPress={() => setEvidenceType(type)}>
+                <Text
+                  style={[
+                    styles.evidenceTypeText,
+                    evidenceType === type && styles.evidenceTypeTextSelected,
+                  ]}>
+                  {type.replace(/_/g, ' ')}
+                </Text>
+              </TouchableOpacity>
+            ))}
+          </View>
+          <Text style={styles.formLabel}>Description</Text>
+          <TextInput
+            style={styles.formInput}
+            value={description}
+            onChangeText={setDescription}
+            placeholder="Describe the evidence..."
+            multiline
+            numberOfLines={4}
+          />
+          <Text style={styles.formLabel}>Reference/URL</Text>
+          <TextInput
+            style={styles.formInput}
+            value={reference}
+            onChangeText={setReference}
+            placeholder="https://..."
+            autoCapitalize="none"
+          />
+        </ScrollView>
+      </SafeAreaView>
+    </Modal>
+  );
+};
+
+/** Create dispute form component */
+const CreateDisputeForm: React.FC<{
+  visible: boolean;
+  onClose: () => void;
+  onSubmit: (data: {
+    chargeId: string;
+    reason: DisputeReason;
+    amount: number;
+    currency: string;
+    subscriptionId?: string;
+  }) => void;
+}> = ({ visible, onClose, onSubmit }) => {
+  const [chargeId, setChargeId] = useState('');
+  const [reason, setReason] = useState<DisputeReason>(DisputeReason.Other);
+  const [amount, setAmount] = useState('');
+  const [currency, setCurrency] = useState('USD');
+
+  const handleSubmit = () => {
+    if (!chargeId.trim()) {
+      Alert.alert('Error', 'Please enter a charge ID');
+      return;
+    }
+    if (!amount.trim() || isNaN(Number(amount))) {
+      Alert.alert('Error', 'Please enter a valid amount');
+      return;
+    }
+
+    onSubmit({
+      chargeId: chargeId.trim(),
+      reason,
+      amount: Number(amount),
+      currency,
+    });
+
+    // Reset form
+    setChargeId('');
+    setReason(DisputeReason.Other);
+    setAmount('');
+    setCurrency('USD');
+    onClose();
+  };
+
+  return (
+    <Modal visible={visible} animationType="slide" presentationStyle="pageSheet">
+      <SafeAreaView style={styles.formModal}>
+        <View style={styles.formHeader}>
+          <TouchableOpacity onPress={onClose}>
+            <Text style={styles.formCancel}>Cancel</Text>
+          </TouchableOpacity>
+          <Text style={styles.formTitle}>Create Dispute</Text>
+          <TouchableOpacity onPress={handleSubmit}>
+            <Text style={styles.formSubmit}>Create</Text>
+          </TouchableOpacity>
+        </View>
+        <ScrollView style={styles.formContent}>
+          <Text style={styles.formLabel}>Charge ID *</Text>
+          <TextInput
+            style={styles.formInput}
+            value={chargeId}
+            onChangeText={setChargeId}
+            placeholder="Enter charge ID"
+          />
+          <Text style={styles.formLabel}>Reason *</Text>
+          <View style={styles.reasonGrid}>
+            {Object.values(DisputeReason).map((r) => (
+              <TouchableOpacity
+                key={r}
+                style={[
+                  styles.reasonButton,
+                  reason === r && styles.reasonButtonSelected,
+                ]}
+                onPress={() => setReason(r)}>
+                <Text
+                  style={[
+                    styles.reasonText,
+                    reason === r && styles.reasonTextSelected,
+                  ]}>
+                  {r.replace(/_/g, ' ')}
+                </Text>
+              </TouchableOpacity>
+            ))}
+          </View>
+          <Text style={styles.formLabel}>Amount *</Text>
+          <TextInput
+            style={styles.formInput}
+            value={amount}
+            onChangeText={setAmount}
+            placeholder="0.00"
+            keyboardType="decimal-pad"
+          />
+          <Text style={styles.formLabel}>Currency</Text>
+          <TextInput
+            style={styles.formInput}
+            value={currency}
+            onChangeText={setCurrency}
+            placeholder="USD"
+            maxLength={3}
+          />
+        </ScrollView>
+      </SafeAreaView>
+    </Modal>
+  );
+};
+
+/** Resolution form component */
+const ResolutionForm: React.FC<{
+  visible: boolean;
+  onClose: () => void;
+  onSubmit: (resolution: Resolution, notes?: string) => void;
+}> = ({ visible, onClose, onSubmit }) => {
+  const [resolution, setResolution] = useState<Resolution>(Resolution.Refund);
+  const [notes, setNotes] = useState('');
+
+  const handleSubmit = () => {
+    onSubmit(resolution, notes.trim() || undefined);
+    setResolution(Resolution.Refund);
+    setNotes('');
+    onClose();
+  };
+
+  return (
+    <Modal visible={visible} animationType="slide" presentationStyle="pageSheet">
+      <SafeAreaView style={styles.formModal}>
+        <View style={styles.formHeader}>
+          <TouchableOpacity onPress={onClose}>
+            <Text style={styles.formCancel}>Cancel</Text>
+          </TouchableOpacity>
+          <Text style={styles.formTitle}>Resolve Dispute</Text>
+          <TouchableOpacity onPress={handleSubmit}>
+            <Text style={styles.formSubmit}>Resolve</Text>
+          </TouchableOpacity>
+        </View>
+        <ScrollView style={styles.formContent}>
+          <Text style={styles.formLabel}>Resolution *</Text>
+          <View style={styles.resolutionGrid}>
+            {Object.values(Resolution).map((r) => (
+              <TouchableOpacity
+                key={r}
+                style={[
+                  styles.resolutionButton,
+                  resolution === r && styles.resolutionButtonSelected,
+                ]}
+                onPress={() => setResolution(r)}>
+                <Text
+                  style={[
+                    styles.resolutionText,
+                    resolution === r && styles.resolutionTextSelected,
+                  ]}>
+                  {r.charAt(0).toUpperCase() + r.slice(1).replace(/_/g, ' ')}
+                </Text>
+              </TouchableOpacity>
+            ))}
+          </View>
+          <Text style={styles.formLabel}>Notes (Optional)</Text>
+          <TextInput
+            style={styles.formInput}
+            value={notes}
+            onChangeText={setNotes}
+            placeholder="Add resolution notes..."
+            multiline
+            numberOfLines={4}
+          />
+        </ScrollView>
+      </SafeAreaView>
+    </Modal>
+  );
+};
+
+/** Dispute detail modal */
+const DisputeDetailModal: React.FC<{
+  visible: boolean;
+  dispute: Dispute | null;
+  onClose: () => void;
+  onSubmitEvidence: () => void;
+  onRequestReview: () => void;
+  onResolve: () => void;
+}> = ({ visible, dispute, onClose, onSubmitEvidence, onRequestReview, onResolve }) => {
+  if (!dispute) return null;
+
+  const formatDate = (date: Date) => {
+    return new Date(date).toLocaleDateString('en-US', {
+      month: 'short',
+      day: 'numeric',
+      year: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit',
+    });
+  };
+
+  return (
+    <Modal visible={visible} animationType="slide" presentationStyle="pageSheet">
+      <SafeAreaView style={styles.detailModal}>
+        <View style={styles.detailHeader}>
+          <Text style={styles.detailTitle}>Dispute Details</Text>
+          <TouchableOpacity onPress={onClose}>
+            <Text style={styles.detailClose}>Close</Text>
+          </TouchableOpacity>
+        </View>
+        <ScrollView style={styles.detailContent}>
+          <View style={styles.detailSection}>
+            <Text style={styles.detailSectionTitle}>Charge Information</Text>
+            <Text style={styles.detailText}>Charge ID: {dispute.chargeId}</Text>
+            <Text style={styles.detailText}>
+              Amount: ${dispute.amount.toFixed(2)} {dispute.currency}
+            </Text>
+            {dispute.subscriptionId && (
+              <Text style={styles.detailText}>
+                Subscription: {dispute.subscriptionName || dispute.subscriptionId}
+              </Text>
+            )}
+          </View>
+
+          <View style={styles.detailSection}>
+            <Text style={styles.detailSectionTitle}>Status</Text>
+            <View style={styles.detailRow}>
+              <ReasonBadge reason={dispute.reason} />
+              <StatusBadge status={dispute.status} />
+            </View>
+          </View>
+
+          <View style={styles.detailSection}>
+            <Text style={styles.detailSectionTitle}>Timeline</Text>
+            {dispute.timeline.map((event, index) => (
+              <View key={event.id} style={styles.timelineItem}>
+                <View style={styles.timelineDot} />
+                <View style={styles.timelineContent}>
+                  <Text style={styles.timelineDescription}>{event.description}</Text>
+                  <Text style={styles.timelineDate}>{formatDate(event.timestamp)}</Text>
+                </View>
+              </View>
+            ))}
+          </View>
+
+          {dispute.evidence.length > 0 && (
+            <View style={styles.detailSection}>
+              <Text style={styles.detailSectionTitle}>
+                Evidence ({dispute.evidence.length})
+              </Text>
+              {dispute.evidence.map((ev) => (
+                <View key={ev.id} style={styles.evidenceItem}>
+                  <Text style={styles.evidenceType}>
+                    {ev.evidenceType.replace(/_/g, ' ')}
+                  </Text>
+                  <Text style={styles.evidenceDescription}>{ev.description}</Text>
+                  {ev.reference && (
+                    <Text style={styles.evidenceReference}>{ev.reference}</Text>
+                  )}
+                  <Text style={styles.evidenceDate}>
+                    Submitted: {formatDate(ev.submittedAt)}
+                  </Text>
+                </View>
+              ))}
+            </View>
+          )}
+
+          {dispute.resolution && (
+            <View style={styles.detailSection}>
+              <Text style={styles.detailSectionTitle}>Resolution</Text>
+              <Text style={styles.detailText}>
+                Outcome: {dispute.resolution.charAt(0).toUpperCase() + dispute.resolution.slice(1)}
+              </Text>
+              {dispute.resolutionNotes && (
+                <Text style={styles.detailText}>Notes: {dispute.resolutionNotes}</Text>
+              )}
+              {dispute.resolvedAt && (
+                <Text style={styles.detailText}>
+                  Resolved: {formatDate(dispute.resolvedAt)}
+                </Text>
+              )}
+            </View>
+          )}
+        </ScrollView>
+
+        {dispute.status !== DisputeStatus.Resolved &&
+          dispute.status !== DisputeStatus.Rejected &&
+          dispute.status !== DisputeStatus.Expired && (
+            <View style={styles.detailActions}>
+              <TouchableOpacity
+                style={styles.detailActionButton}
+                onPress={onSubmitEvidence}>
+                <Text style={styles.detailActionText}>Submit Evidence</Text>
+              </TouchableOpacity>
+              <TouchableOpacity
+                style={[styles.detailActionButton, styles.secondaryButton]}
+                onPress={onRequestReview}>
+                <Text style={[styles.detailActionText, styles.secondaryText]}>
+                  Request Review
+                </Text>
+              </TouchableOpacity>
+              <TouchableOpacity
+                style={[styles.detailActionButton, styles.dangerButton]}
+                onPress={onResolve}>
+                <Text style={[styles.detailActionText, styles.dangerText]}>
+                  Resolve
+                </Text>
+              </TouchableOpacity>
+            </View>
+          )}
+      </SafeAreaView>
+    </Modal>
+  );
+};
+
+// ════════════════════════════════════════════════════════════════
+// MAIN SCREEN
+// ════════════════════════════════════════════════════════════════
+
+const DisputeManagementScreen: React.FC = () => {
+  const navigation = useNavigation<HomeNavigationProp>();
+  const {
+    disputes,
+    analytics,
+    createDispute,
+    submitEvidence,
+    requestManualReview,
+    resolveDispute,
+    updateAnalytics,
+  } = useDisputeStore();
+
+  const [refreshing, setRefreshing] = useState(false);
+  const [selectedDispute, setSelectedDispute] = useState<Dispute | null>(null);
+  const [showCreateForm, setShowCreateForm] = useState(false);
+  const [showEvidenceForm, setShowEvidenceForm] = useState(false);
+  const [showResolutionForm, setShowResolutionForm] = useState(false);
+  const [filterStatus, setFilterStatus] = useState<DisputeStatus | 'all'>('all');
+
+  // Filter disputes
+  const filteredDisputes = useMemo(() => {
+    if (filterStatus === 'all') return disputes;
+    return disputes.filter((d) => d.status === filterStatus);
+  }, [disputes, filterStatus]);
+
+  // Update analytics on mount
+  useEffect(() => {
+    updateAnalytics();
+  }, [updateAnalytics]);
+
+  const onRefresh = async () => {
+    setRefreshing(true);
+    updateAnalytics();
+    setRefreshing(false);
+  };
+
+  const handleCreateDispute = async (data: {
+    chargeId: string;
+    reason: DisputeReason;
+    amount: number;
+    currency: string;
+    subscriptionId?: string;
+  }) => {
+    try {
+      await createDispute(data, 'current-user');
+      Alert.alert('Success', 'Dispute created successfully');
+    } catch (error) {
+      Alert.alert('Error', 'Failed to create dispute');
+    }
+  };
+
+  const handleSubmitEvidence = async (evidence: EvidenceFormData) => {
+    if (!selectedDispute) return;
+    try {
+      await submitEvidence(selectedDispute.id, evidence, 'current-user');
+      Alert.alert('Success', 'Evidence submitted successfully');
+      setShowEvidenceForm(false);
+    } catch (error) {
+      Alert.alert('Error', 'Failed to submit evidence');
+    }
+  };
+
+  const handleRequestReview = async () => {
+    if (!selectedDispute) return;
+    try {
+      await requestManualReview(selectedDispute.id, 'current-user');
+      Alert.alert('Success', 'Manual review requested');
+    } catch (error) {
+      Alert.alert('Error', 'Failed to request review');
+    }
+  };
+
+  const handleResolve = async (resolution: Resolution, notes?: string) => {
+    if (!selectedDispute) return;
+    try {
+      await resolveDispute(selectedDispute.id, resolution, notes, 'admin');
+      Alert.alert('Success', 'Dispute resolved successfully');
+      setShowResolutionForm(false);
+      setSelectedDispute(null);
+    } catch (error) {
+      Alert.alert('Error', 'Failed to resolve dispute');
+    }
+  };
+
+  const handleDisputePress = (dispute: Dispute) => {
+    setSelectedDispute(dispute);
+  };
+
+  const renderDisputeItem = ({ item }: { item: Dispute }) => (
+    <DisputeItem dispute={item} onPress={handleDisputePress} />
+  );
+
+  return (
+    <SafeAreaView style={styles.container}>
+      <ScrollView
+        style={styles.scrollView}
+        refreshControl={
+          <RefreshControl
+            refreshing={refreshing}
+            onRefresh={onRefresh}
+            tintColor={colors.primary}
+          />
+        }>
+        <View style={styles.header}>
+          <Text style={styles.title}>Dispute Management</Text>
+          <TouchableOpacity
+            style={styles.addButton}
+            onPress={() => setShowCreateForm(true)}>
+            <Text style={styles.addButtonText}>+ New</Text>
+          </TouchableOpacity>
+        </View>
+
+        {/* Analytics Card */}
+        <AnalyticsCard analytics={analytics} />
+
+        {/* Filter */}
+        <View style={styles.filterContainer}>
+          <ScrollView horizontal showsHorizontalScrollIndicator={false}>
+            <TouchableOpacity
+              style={[
+                styles.filterButton,
+                filterStatus === 'all' && styles.filterButtonActive,
+              ]}
+              onPress={() => setFilterStatus('all')}>
+              <Text
+                style={[
+                  styles.filterText,
+                  filterStatus === 'all' && styles.filterTextActive,
+                ]}>
+                All
+              </Text>
+            </TouchableOpacity>
+            {Object.values(DisputeStatus).map((status) => (
+              <TouchableOpacity
+                key={status}
+                style={[
+                  styles.filterButton,
+                  filterStatus === status && styles.filterButtonActive,
+                ]}
+                onPress={() => setFilterStatus(status)}>
+                <Text
+                  style={[
+                    styles.filterText,
+                    filterStatus === status && styles.filterTextActive,
+                  ]}>
+                  {status.replace(/_/g, ' ')}
+                </Text>
+              </TouchableOpacity>
+            ))}
+          </ScrollView>
+        </View>
+
+        {/* Dispute List */}
+        <View style={styles.listContainer}>
+          <Text style={styles.listTitle}>
+            Disputes ({filteredDisputes.length})
+          </Text>
+          {filteredDisputes.length === 0 ? (
+            <View style={styles.emptyState}>
+              <Text style={styles.emptyText}>No disputes found</Text>
+              <Text style={styles.emptySubtext}>
+                Create a new dispute to get started
+              </Text>
+            </View>
+          ) : (
+            filteredDisputes.map((dispute) => (
+              <DisputeItem
+                key={dispute.id}
+                dispute={dispute}
+                onPress={handleDisputePress}
+              />
+            ))
+          )}
+        </View>
+      </ScrollView>
+
+      {/* Modals */}
+      <CreateDisputeForm
+        visible={showCreateForm}
+        onClose={() => setShowCreateForm(false)}
+        onSubmit={handleCreateDispute}
+      />
+
+      <DisputeDetailModal
+        visible={!!selectedDispute}
+        dispute={selectedDispute}
+        onClose={() => setSelectedDispute(null)}
+        onSubmitEvidence={() => setShowEvidenceForm(true)}
+        onRequestReview={handleRequestReview}
+        onResolve={() => setShowResolutionForm(true)}
+      />
+
+      <EvidenceForm
+        visible={showEvidenceForm}
+        onClose={() => setShowEvidenceForm(false)}
+        onSubmit={handleSubmitEvidence}
+      />
+
+      <ResolutionForm
+        visible={showResolutionForm}
+        onClose={() => setShowResolutionForm(false)}
+        onSubmit={handleResolve}
+      />
+    </SafeAreaView>
+  );
+};
+
+// ════════════════════════════════════════════════════════════════
+// STYLES
+// ════════════════════════════════════════════════════════════════
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: colors.background,
+  },
+  scrollView: {
+    flex: 1,
+  },
+  header: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+    paddingHorizontal: spacing.lg,
+    paddingVertical: spacing.md,
+  },
+  title: {
+    fontSize: typography.xl,
+    fontWeight: 'bold',
+    color: colors.text,
+  },
+  addButton: {
+    backgroundColor: colors.primary,
+    paddingHorizontal: spacing.md,
+    paddingVertical: spacing.sm,
+    borderRadius: borderRadius.md,
+  },
+  addButtonText: {
+    color: colors.white,
+    fontWeight: '600',
+  },
+  analyticsCard: {
+    backgroundColor: colors.card,
+    marginHorizontal: spacing.lg,
+    marginVertical: spacing.md,
+    padding: spacing.lg,
+    borderRadius: borderRadius.lg,
+    shadowColor: colors.shadow,
+    shadowOffset: { width: 0, height: 2 },
+    shadowOpacity: 0.1,
+    shadowRadius: 4,
+    elevation: 3,
+  },
+  analyticsTitle: {
+    fontSize: typography.lg,
+    fontWeight: '600',
+    color: colors.text,
+    marginBottom: spacing.md,
+  },
+  analyticsGrid: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    marginBottom: spacing.md,
+  },
+  analyticsItem: {
+    alignItems: 'center',
+  },
+  analyticsValue: {
+    fontSize: typography.xl,
+    fontWeight: 'bold',
+    color: colors.text,
+  },
+  analyticsLabel: {
+    fontSize: typography.sm,
+    color: colors.muted,
+    marginTop: spacing.xs,
+  },
+  analyticsRow: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    paddingTop: spacing.md,
+    borderTopWidth: 1,
+    borderTopColor: colors.border,
+  },
+  analyticsText: {
+    fontSize: typography.sm,
+    color: colors.muted,
+  },
+  filterContainer: {
+    paddingHorizontal: spacing.lg,
+    paddingVertical: spacing.sm,
+  },
+  filterButton: {
+    paddingHorizontal: spacing.md,
+    paddingVertical: spacing.sm,
+    marginRight: spacing.sm,
+    borderRadius: borderRadius.md,
+    backgroundColor: colors.card,
+  },
+  filterButtonActive: {
+    backgroundColor: colors.primary,
+  },
+  filterText: {
+    fontSize: typography.sm,
+    color: colors.muted,
+  },
+  filterTextActive: {
+    color: colors.white,
+    fontWeight: '600',
+  },
+  listContainer: {
+    paddingHorizontal: spacing.lg,
+    paddingVertical: spacing.md,
+  },
+  listTitle: {
+    fontSize: typography.lg,
+    fontWeight: '600',
+    color: colors.text,
+    marginBottom: spacing.md,
+  },
+  emptyState: {
+    alignItems: 'center',
+    paddingVertical: spacing.xl,
+  },
+  emptyText: {
+    fontSize: typography.lg,
+    color: colors.muted,
+  },
+  emptySubtext: {
+    fontSize: typography.sm,
+    color: colors.muted,
+    marginTop: spacing.xs,
+  },
+  disputeItem: {
+    backgroundColor: colors.card,
+    padding: spacing.md,
+    borderRadius: borderRadius.lg,
+    marginBottom: spacing.md,
+  },
+  disputeItemHeader: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    marginBottom: spacing.sm,
+  },
+  disputeItemInfo: {
+    flex: 1,
+  },
+  disputeItemCharge: {
+    fontSize: typography.md,
+    fontWeight: '600',
+    color: colors.text,
+  },
+  disputeItemDate: {
+    fontSize: typography.sm,
+    color: colors.muted,
+    marginTop: spacing.xs,
+  },
+  disputeItemAmount: {
+    alignItems: 'flex-end',
+  },
+  disputeItemAmountText: {
+    fontSize: typography.lg,
+    fontWeight: 'bold',
+    color: colors.text,
+  },
+  disputeItemCurrency: {
+    fontSize: typography.sm,
+    color: colors.muted,
+  },
+  disputeItemBody: {
+    flexDirection: 'row',
+    gap: spacing.sm,
+    marginBottom: spacing.sm,
+  },
+  disputeItemFooter: {
+    paddingTop: spacing.sm,
+    borderTopWidth: 1,
+    borderTopColor: colors.border,
+  },
+  statusBadge: {
+    paddingHorizontal: spacing.sm,
+    paddingVertical: spacing.xs,
+    borderRadius: borderRadius.sm,
+  },
+  statusBadgeText: {
+    fontSize: typography.xs,
+    fontWeight: '600',
+  },
+  reasonBadge: {
+    backgroundColor: colors.muted + '20',
+    paddingHorizontal: spacing.sm,
+    paddingVertical: spacing.xs,
+    borderRadius: borderRadius.sm,
+  },
+  reasonBadgeText: {
+    fontSize: typography.xs,
+    color: colors.text,
+  },
+  daysRemaining: {
+    fontSize: typography.sm,
+    color: colors.muted,
+  },
+  daysRemainingUrgent: {
+    color: colors.error,
+  },
+  formModal: {
+    flex: 1,
+    backgroundColor: colors.background,
+  },
+  formHeader: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+    paddingHorizontal: spacing.lg,
+    paddingVertical: spacing.md,
+    borderBottomWidth: 1,
+    borderBottomColor: colors.border,
+  },
+  formTitle: {
+    fontSize: typography.lg,
+    fontWeight: '600',
+    color: colors.text,
+  },
+  formCancel: {
+    fontSize: typography.md,
+    color: colors.muted,
+  },
+  formSubmit: {
+    fontSize: typography.md,
+    color: colors.primary,
+    fontWeight: '600',
+  },
+  formContent: {
+    flex: 1,
+    padding: spacing.lg,
+  },
+  formLabel: {
+    fontSize: typography.md,
+    fontWeight: '600',
+    color: colors.text,
+    marginBottom: spacing.sm,
+    marginTop: spacing.md,
+  },
+  formInput: {
+    backgroundColor: colors.card,
+    padding: spacing.md,
+    borderRadius: borderRadius.md,
+    fontSize: typography.md,
+    color: colors.text,
+    borderWidth: 1,
+    borderColor: colors.border,
+  },
+  evidenceTypeGrid: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: spacing.sm,
+  },
+  evidenceTypeButton: {
+    paddingHorizontal: spacing.md,
+    paddingVertical: spacing.sm,
+    borderRadius: borderRadius.md,
+    backgroundColor: colors.card,
+    borderWidth: 1,
+    borderColor: colors.border,
+  },
+  evidenceTypeButtonSelected: {
+    backgroundColor: colors.primary,
+    borderColor: colors.primary,
+  },
+  evidenceTypeText: {
+    fontSize: typography.sm,
+    color: colors.text,
+  },
+  evidenceTypeTextSelected: {
+    color: colors.white,
+  },
+  reasonGrid: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: spacing.sm,
+  },
+  reasonButton: {
+    paddingHorizontal: spacing.md,
+    paddingVertical: spacing.sm,
+    borderRadius: borderRadius.md,
+    backgroundColor: colors.card,
+    borderWidth: 1,
+    borderColor: colors.border,
+  },
+  reasonButtonSelected: {
+    backgroundColor: colors.primary,
+    borderColor: colors.primary,
+  },
+  reasonText: {
+    fontSize: typography.sm,
+    color: colors.text,
+  },
+  reasonTextSelected: {
+    color: colors.white,
+  },
+  resolutionGrid: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: spacing.sm,
+  },
+  resolutionButton: {
+    paddingHorizontal: spacing.md,
+    paddingVertical: spacing.sm,
+    borderRadius: borderRadius.md,
+    backgroundColor: colors.card,
+    borderWidth: 1,
+    borderColor: colors.border,
+  },
+  resolutionButtonSelected: {
+    backgroundColor: colors.success,
+    borderColor: colors.success,
+  },
+  resolutionText: {
+    fontSize: typography.sm,
+    color: colors.text,
+  },
+  resolutionTextSelected: {
+    color: colors.white,
+  },
+  detailModal: {
+    flex: 1,
+    backgroundColor: colors.background,
+  },
+  detailHeader: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+    paddingHorizontal: spacing.lg,
+    paddingVertical: spacing.md,
+    borderBottomWidth: 1,
+    borderBottomColor: colors.border,
+  },
+  detailTitle: {
+    fontSize: typography.lg,
+    fontWeight: '600',
+    color: colors.text,
+  },
+  detailClose: {
+    fontSize: typography.md,
+    color: colors.primary,
+  },
+  detailContent: {
+    flex: 1,
+    padding: spacing.lg,
+  },
+  detailSection: {
+    marginBottom: spacing.lg,
+  },
+  detailSectionTitle: {
+    fontSize: typography.md,
+    fontWeight: '600',
+    color: colors.text,
+    marginBottom: spacing.sm,
+  },
+  detailRow: {
+    flexDirection: 'row',
+    gap: spacing.sm,
+  },
+  detailText: {
+    fontSize: typography.sm,
+    color: colors.text,
+    marginBottom: spacing.xs,
+  },
+  timelineItem: {
+    flexDirection: 'row',
+    marginBottom: spacing.md,
+  },
+  timelineDot: {
+    width: 10,
+    height: 10,
+    borderRadius: 5,
+    backgroundColor: colors.primary,
+    marginTop: 4,
+    marginRight: spacing.md,
+  },
+  timelineContent: {
+    flex: 1,
+  },
+  timelineDescription: {
+    fontSize: typography.sm,
+    color: colors.text,
+  },
+  timelineDate: {
+    fontSize: typography.xs,
+    color: colors.muted,
+    marginTop: spacing.xs,
+  },
+  evidenceItem: {
+    backgroundColor: colors.card,
+    padding: spacing.md,
+    borderRadius: borderRadius.md,
+    marginBottom: spacing.sm,
+  },
+  evidenceType: {
+    fontSize: typography.sm,
+    fontWeight: '600',
+    color: colors.primary,
+  },
+  evidenceDescription: {
+    fontSize: typography.sm,
+    color: colors.text,
+    marginTop: spacing.xs,
+  },
+  evidenceReference: {
+    fontSize: typography.xs,
+    color: colors.primary,
+    marginTop: spacing.xs,
+  },
+  evidenceDate: {
+    fontSize: typography.xs,
+    color: colors.muted,
+    marginTop: spacing.xs,
+  },
+  detailActions: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    padding: spacing.lg,
+    borderTopWidth: 1,
+    borderTopColor: colors.border,
+  },
+  detailActionButton: {
+    flex: 1,
+    backgroundColor: colors.primary,
+    padding: spacing.md,
+    borderRadius: borderRadius.md,
+    marginHorizontal: spacing.xs,
+    alignItems: 'center',
+  },
+  detailActionText: {
+    color: colors.white,
+    fontWeight: '600',
+    fontSize: typography.sm,
+  },
+  secondaryButton: {
+    backgroundColor: colors.secondary,
+  },
+  secondaryText: {
+    color: colors.white,
+  },
+  dangerButton: {
+    backgroundColor: colors.error,
+  },
+  dangerText: {
+    color: colors.white,
+  },
+});
+
+export default DisputeManagementScreen;
\ No newline at end of file
diff --git a/src/screens/ExportScreen.tsx b/src/screens/ExportScreen.tsx
new file mode 100644
index 0000000..df35be6
--- /dev/null
+++ b/src/screens/ExportScreen.tsx
@@ -0,0 +1,511 @@
+import React, { useState, useCallback } from 'react';
+import {
+  View,
+  Text,
+  StyleSheet,
+  SafeAreaView,
+  ScrollView,
+  TouchableOpacity,
+  Alert,
+  Share,
+  ActivityIndicator,
+  Clipboard,
+  Platform,
+} from 'react-native';
+import { useNavigation } from '@react-navigation/native';
+import { NativeStackNavigationProp } from '@react-navigation/native-stack';
+import { RootStackParamList } from '../navigation/types';
+import { colors, spacing, typography, borderRadius } from '../utils/constants';
+import { Button } from '../components/common/Button';
+import { Card } from '../components/common/Card';
+import {
+  generateCSV,
+  exportToJSON,
+  ExportData,
+  Subscription,
+} from '../utils/importExport';
+import { useSubscriptionStore } from '../store';
+
+type ExportScreenNavigationProp = NativeStackNavigationProp<RootStackParamList, 'Export'>;
+
+type ExportFormat = 'json' | 'csv';
+
+const ExportScreen: React.FC = () => {
+  const navigation = useNavigation<ExportScreenNavigationProp>();
+  const { subscriptions } = useSubscriptionStore();
+
+  const [exportFormat, setExportFormat] = useState<ExportFormat>('json');
+  const [isExporting, setIsExporting] = useState(false);
+  const [exportedData, setExportedData] = useState<string | null>(null);
+  const [showPreview, setShowPreview] = useState(false);
+
+  const handleExport = useCallback(async () => {
+    if (subscriptions.length === 0) {
+      Alert.alert('No Data', 'There are no subscriptions to export.');
+      return;
+    }
+
+    setIsExporting(true);
+
+    try {
+      let data: string;
+      let preview: string;
+
+      if (exportFormat === 'json') {
+        data = exportToJSON(subscriptions);
+        preview = JSON.stringify(JSON.parse(data), null, 2);
+      } else {
+        data = generateCSV(subscriptions);
+        preview = data;
+      }
+
+      setExportedData(data);
+      setShowPreview(true);
+
+      Alert.alert(
+        'Export Ready',
+        `Exported ${subscriptions.length} subscription(s) as ${exportFormat.toUpperCase()}.`,
+        [
+          {
+            text: 'Cancel',
+            style: 'cancel',
+          },
+          {
+            text: 'Share',
+            onPress: () => shareData(data),
+          },
+          {
+            text: 'Copy to Clipboard',
+            onPress: () => copyToClipboard(data),
+          },
+        ]
+      );
+    } catch (error) {
+      Alert.alert(
+        'Error',
+        error instanceof Error ? error.message : 'Failed to export data'
+      );
+    } finally {
+      setIsExporting(false);
+    }
+  }, [subscriptions, exportFormat]);
+
+  const shareData = async (data: string) => {
+    try {
+      await Share.share({
+        message: data,
+        title: `SubTrackr Export (${exportFormat.toUpperCase()})`,
+      });
+    } catch (error) {
+      Alert.alert('Error', 'Failed to share data');
+    }
+  };
+
+  const copyToClipboard = (data: string) => {
+    Clipboard.setString(data);
+    Alert.alert('Copied', `${exportFormat.toUpperCase()} data copied to clipboard`);
+  };
+
+  const downloadFile = () => {
+    if (!exportedData) return;
+
+    // In a real implementation, this would use a file system library
+    // like expo-file-system to save the file
+    Alert.alert(
+      'Download',
+      'In a production app, this would save the file to the device storage.',
+      [
+        { text: 'OK' },
+      ]
+    );
+  };
+
+  const renderFormatSelector = () => (
+    <View style={styles.formatContainer}>
+      <Text style={styles.sectionTitle}>Export Format</Text>
+      <View style={styles.formatButtons}>
+        <TouchableOpacity
+          style={[
+            styles.formatButton,
+            exportFormat === 'json' && styles.formatButtonActive,
+          ]}
+          onPress={() => setExportFormat('json')}
+        >
+          <Text
+            style={[
+              styles.formatButtonText,
+              exportFormat === 'json' && styles.formatButtonTextActive,
+            ]}
+          >
+            JSON
+          </Text>
+          <Text style={styles.formatButtonSubtext}>
+            Full data with metadata
+          </Text>
+        </TouchableOpacity>
+        <TouchableOpacity
+          style={[
+            styles.formatButton,
+            exportFormat === 'csv' && styles.formatButtonActive,
+          ]}
+          onPress={() => setExportFormat('csv')}
+        >
+          <Text
+            style={[
+              styles.formatButtonText,
+              exportFormat === 'csv' && styles.formatButtonTextActive,
+            ]}
+          >
+            CSV
+          </Text>
+          <Text style={styles.formatButtonSubtext}>
+            Spreadsheet compatible
+          </Text>
+        </TouchableOpacity>
+      </View>
+    </View>
+  );
+
+  const renderSubscriptionStats = () => (
+    <Card style={styles.statsCard}>
+      <Text style={styles.sectionTitle}>Export Summary</Text>
+      <View style={styles.statsGrid}>
+        <View style={styles.statItem}>
+          <Text style={styles.statValue}>{subscriptions.length}</Text>
+          <Text style={styles.statLabel}>Total Subscriptions</Text>
+        </View>
+        <View style={styles.statItem}>
+          <Text style={styles.statValue}>
+            {subscriptions.filter((s) => s.isActive).length}
+          </Text>
+          <Text style={styles.statLabel}>Active</Text>
+        </View>
+        <View style={styles.statItem}>
+          <Text style={styles.statValue}>
+            {subscriptions.filter((s) => !s.isActive).length}
+          </Text>
+          <Text style={styles.statLabel}>Paused</Text>
+        </View>
+      </View>
+      <View style={styles.categoryBreakdown}>
+        <Text style={styles.categoryTitle}>By Category</Text>
+        {getCategoryStats().map((cat) => (
+          <View key={cat.name} style={styles.categoryRow}>
+            <Text style={styles.categoryName}>{cat.name}</Text>
+            <Text style={styles.categoryCount}>{cat.count}</Text>
+          </View>
+        ))}
+      </View>
+    </Card>
+  );
+
+  const getCategoryStats = () => {
+    const categoryMap = new Map<string, number>();
+    subscriptions.forEach((sub) => {
+      const count = categoryMap.get(sub.category) || 0;
+      categoryMap.set(sub.category, count + 1);
+    });
+
+    return Array.from(categoryMap.entries())
+      .map(([name, count]) => ({ name: name.charAt(0).toUpperCase() + name.slice(1), count }))
+      .sort((a, b) => b.count - a.count);
+  };
+
+  const renderPreview = () => {
+    if (!showPreview || !exportedData) return null;
+
+    const previewText = exportedData.length > 500 
+      ? exportedData.substring(0, 500) + '...'
+      : exportedData;
+
+    return (
+      <Card style={styles.previewCard}>
+        <View style={styles.previewHeader}>
+          <Text style={styles.sectionTitle}>Preview</Text>
+          <TouchableOpacity onPress={() => setShowPreview(false)}>
+            <Text style={styles.hidePreview}>Hide</Text>
+          </TouchableOpacity>
+        </View>
+        <View style={styles.previewContent}>
+          <Text style={styles.previewText}>{previewText}</Text>
+        </View>
+      </Card>
+    );
+  };
+
+  const renderActions = () => (
+    <View style={styles.actionsContainer}>
+      <Button
+        title={isExporting ? 'Exporting...' : `Export as ${exportFormat.toUpperCase()}`}
+        onPress={handleExport}
+        disabled={isExporting || subscriptions.length === 0}
+        loading={isExporting}
+      />
+      
+      {exportedData && (
+        <View style={styles.actionButtons}>
+          <TouchableOpacity
+            style={styles.actionButton}
+            onPress={() => shareData(exportedData)}
+          >
+            <Text style={styles.actionButtonText}>Share</Text>
+          </TouchableOpacity>
+          <TouchableOpacity
+            style={styles.actionButton}
+            onPress={() => copyToClipboard(exportedData)}
+          >
+            <Text style={styles.actionButtonText}>Copy</Text>
+          </TouchableOpacity>
+          <TouchableOpacity
+            style={styles.actionButton}
+            onPress={downloadFile}
+          >
+            <Text style={styles.actionButtonText}>Download</Text>
+          </TouchableOpacity>
+        </View>
+      )}
+    </View>
+  );
+
+  const renderInfo = () => (
+    <Card style={styles.infoCard}>
+      <Text style={styles.infoTitle}>Export Information</Text>
+      <View style={styles.infoRow}>
+        <Text style={styles.infoLabel}>JSON Format:</Text>
+        <Text style={styles.infoValue}>
+          Full export with version, timestamp, and all subscription data
+        </Text>
+      </View>
+      <View style={styles.infoRow}>
+        <Text style={styles.infoLabel}>CSV Format:</Text>
+        <Text style={styles.infoValue}>
+          Tabular format compatible with Excel, Google Sheets, etc.
+        </Text>
+      </View>
+      <View style={styles.infoRow}>
+        <Text style={styles.infoLabel}>Data Included:</Text>
+        <Text style={styles.infoValue}>
+          Name, description, category, price, currency, billing cycle, dates, and settings
+        </Text>
+      </View>
+    </Card>
+  );
+
+  return (
+    <SafeAreaView style={styles.container}>
+      <ScrollView style={styles.scrollView}>
+        <View style={styles.header}>
+          <Text style={styles.title}>Export Subscriptions</Text>
+          <Text style={styles.subtitle}>
+            Export your subscription data for backup or migration
+          </Text>
+        </View>
+
+        {renderSubscriptionStats()}
+        {renderFormatSelector()}
+        {renderInfo()}
+        {renderPreview()}
+        {renderActions()}
+
+        {subscriptions.length === 0 && (
+          <View style={styles.emptyState}>
+            <Text style={styles.emptyTitle}>No Subscriptions</Text>
+            <Text style={styles.emptyText}>
+              Add some subscriptions first before exporting.
+            </Text>
+          </View>
+        )}
+      </ScrollView>
+    </SafeAreaView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: colors.background,
+  },
+  scrollView: {
+    flex: 1,
+  },
+  header: {
+    padding: spacing.lg,
+    paddingTop: spacing.xl,
+  },
+  title: {
+    ...typography.h1,
+    color: colors.text,
+  },
+  subtitle: {
+    ...typography.body,
+    color: colors.textSecondary,
+    marginTop: spacing.xs,
+  },
+  statsCard: {
+    margin: spacing.lg,
+    marginTop: 0,
+  },
+  sectionTitle: {
+    ...typography.h3,
+    color: colors.text,
+    marginBottom: spacing.md,
+  },
+  statsGrid: {
+    flexDirection: 'row',
+    justifyContent: 'space-around',
+    marginBottom: spacing.lg,
+  },
+  statItem: {
+    alignItems: 'center',
+  },
+  statValue: {
+    ...typography.h1,
+    color: colors.primary,
+  },
+  statLabel: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    marginTop: spacing.xs,
+  },
+  categoryBreakdown: {
+    borderTopWidth: 1,
+    borderTopColor: colors.border,
+    paddingTop: spacing.md,
+  },
+  categoryTitle: {
+    ...typography.body,
+    color: colors.textSecondary,
+    marginBottom: spacing.sm,
+  },
+  categoryRow: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    paddingVertical: spacing.xs,
+  },
+  categoryName: {
+    ...typography.body,
+    color: colors.text,
+  },
+  categoryCount: {
+    ...typography.body,
+    color: colors.textSecondary,
+  },
+  formatContainer: {
+    padding: spacing.lg,
+    paddingTop: 0,
+  },
+  formatButtons: {
+    flexDirection: 'row',
+    marginTop: spacing.md,
+    gap: spacing.md,
+  },
+  formatButton: {
+    flex: 1,
+    padding: spacing.lg,
+    borderRadius: borderRadius.md,
+    borderWidth: 1,
+    borderColor: colors.border,
+    backgroundColor: colors.surface,
+  },
+  formatButtonActive: {
+    borderColor: colors.primary,
+    backgroundColor: colors.primary + '20',
+  },
+  formatButtonText: {
+    ...typography.h3,
+    color: colors.text,
+  },
+  formatButtonTextActive: {
+    color: colors.primary,
+  },
+  formatButtonSubtext: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    marginTop: spacing.xs,
+  },
+  infoCard: {
+    margin: spacing.lg,
+    marginTop: 0,
+  },
+  infoTitle: {
+    ...typography.h3,
+    color: colors.text,
+    marginBottom: spacing.md,
+  },
+  infoRow: {
+    marginBottom: spacing.md,
+  },
+  infoLabel: {
+    ...typography.body,
+    color: colors.text,
+    fontWeight: '600',
+    marginBottom: spacing.xs,
+  },
+  infoValue: {
+    ...typography.caption,
+    color: colors.textSecondary,
+  },
+  previewCard: {
+    margin: spacing.lg,
+    marginTop: 0,
+  },
+  previewHeader: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+  },
+  hidePreview: {
+    ...typography.body,
+    color: colors.primary,
+  },
+  previewContent: {
+    backgroundColor: colors.background,
+    borderRadius: borderRadius.md,
+    padding: spacing.md,
+    maxHeight: 200,
+  },
+  previewText: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    fontFamily: Platform.OS === 'ios' ? 'Menlo' : 'monospace',
+  },
+  actionsContainer: {
+    padding: spacing.lg,
+    paddingTop: 0,
+  },
+  actionButtons: {
+    flexDirection: 'row',
+    justifyContent: 'space-around',
+    marginTop: spacing.lg,
+  },
+  actionButton: {
+    padding: spacing.md,
+    backgroundColor: colors.surface,
+    borderRadius: borderRadius.md,
+    borderWidth: 1,
+    borderColor: colors.border,
+    minWidth: 100,
+    alignItems: 'center',
+  },
+  actionButtonText: {
+    ...typography.body,
+    color: colors.primary,
+    fontWeight: '600',
+  },
+  emptyState: {
+    alignItems: 'center',
+    padding: spacing.xl,
+  },
+  emptyTitle: {
+    ...typography.h2,
+    color: colors.text,
+  },
+  emptyText: {
+    ...typography.body,
+    color: colors.textSecondary,
+    marginTop: spacing.md,
+    textAlign: 'center',
+  },
+});
+
+export default ExportScreen;
\ No newline at end of file
diff --git a/src/screens/ImportScreen.tsx b/src/screens/ImportScreen.tsx
new file mode 100644
index 0000000..6a53c54
--- /dev/null
+++ b/src/screens/ImportScreen.tsx
@@ -0,0 +1,701 @@
+import React, { useState, useCallback } from 'react';
+import {
+  View,
+  Text,
+  StyleSheet,
+  SafeAreaView,
+  ScrollView,
+  TouchableOpacity,
+  Alert,
+  TextInput,
+  ActivityIndicator,
+  FlatList,
+  Modal,
+} from 'react-native';
+import { useNavigation } from '@react-navigation/native';
+import { NativeStackNavigationProp } from '@react-navigation/native-stack';
+import { RootStackParamList } from '../navigation/types';
+import { colors, spacing, typography, borderRadius } from '../utils/constants';
+import { Button } from '../components/common/Button';
+import { Card } from '../components/common/Card';
+import {
+  parseCSV,
+  parseJSON,
+  validateImport,
+  processImport,
+  recordImport,
+  getImportHistory,
+  getCSVTemplate,
+  getJSONTemplate,
+  detectFormat,
+  ImportMode,
+  ImportResult,
+  ValidationResult,
+  ImportHistoryEntry,
+  SubscriptionInput,
+} from '../utils/importExport';
+import { useSubscriptionStore } from '../store';
+
+type ImportScreenNavigationProp = NativeStackNavigationProp<RootStackParamList, 'Import'>;
+
+const ImportScreen: React.FC = () => {
+  const navigation = useNavigation<ImportScreenNavigationProp>();
+  const { subscriptions, addSubscription, updateSubscription } = useSubscriptionStore();
+
+  const [importMode, setImportMode] = useState<ImportMode>('upsert');
+  const [importText, setImportText] = useState('');
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [validationResult, setValidationResult] = useState<ValidationResult | null>(null);
+  const [importResult, setImportResult] = useState<ImportResult | null>(null);
+  const [showHistory, setShowHistory] = useState(false);
+  const [importHistory, setImportHistory] = useState<ImportHistoryEntry[]>([]);
+  const [showTemplateModal, setShowTemplateModal] = useState(false);
+
+  const handleImport = useCallback(async () => {
+    if (!importText.trim()) {
+      Alert.alert('Error', 'Please enter data to import');
+      return;
+    }
+
+    setIsProcessing(true);
+    setValidationResult(null);
+    setImportResult(null);
+
+    try {
+      const format = detectFormat(importText);
+      let parsedData: SubscriptionInput[];
+
+      if (format === 'csv') {
+        parsedData = parseCSV(importText);
+      } else if (format === 'json') {
+        parsedData = parseJSON(importText);
+      } else {
+        Alert.alert('Error', 'Unable to detect file format. Please use CSV or JSON format.');
+        setIsProcessing(false);
+        return;
+      }
+
+      // Validate the data
+      const validation = validateImport({ subscriptions: parsedData, mode: importMode });
+      setValidationResult(validation);
+
+      if (validation.validRows.length === 0) {
+        Alert.alert(
+          'Validation Failed',
+          `Found ${validation.errors.length} error(s). Please fix them and try again.`
+        );
+        setIsProcessing(false);
+        return;
+      }
+
+      // Show preview and ask for confirmation
+      Alert.alert(
+        'Import Preview',
+        `Found ${validation.validRows.length} valid subscription(s).\n\n${
+          validation.warnings.length > 0
+            ? `Warnings: ${validation.warnings.length}\n`
+            : ''
+        }Do you want to proceed with the import?`,
+        [
+          {
+            text: 'Cancel',
+            style: 'cancel',
+            onPress: () => setIsProcessing(false),
+          },
+          {
+            text: 'Import',
+            onPress: async () => {
+              await executeImport(parsedData);
+            },
+          },
+        ]
+      );
+    } catch (error) {
+      Alert.alert(
+        'Error',
+        error instanceof Error ? error.message : 'Failed to parse import data'
+      );
+    } finally {
+      setIsProcessing(false);
+    }
+  }, [importText, importMode]);
+
+  const executeImport = async (parsedData: SubscriptionInput[]) => {
+    setIsProcessing(true);
+
+    try {
+      const result = processImport(
+        { subscriptions: parsedData, mode: importMode },
+        subscriptions
+      );
+
+      setImportResult(result);
+
+      // Apply the import
+      if (result.imported > 0 || result.updated > 0) {
+        for (const sub of parsedData) {
+          const existing = subscriptions.find(
+            (s) => s.name.toLowerCase() === sub.name.toLowerCase()
+          );
+
+          if (existing) {
+            // Update existing
+            await updateSubscription(existing.id, {
+              name: sub.name,
+              description: sub.description,
+              category: sub.category as any,
+              price: sub.price,
+              currency: sub.currency,
+              billingCycle: sub.billingCycle as any,
+              nextBillingDate: new Date(sub.nextBillingDate),
+              isActive: sub.isActive ?? true,
+              notificationsEnabled: sub.notificationsEnabled ?? true,
+              isCryptoEnabled: sub.isCryptoEnabled ?? false,
+              cryptoToken: sub.cryptoToken,
+              cryptoAmount: sub.cryptoAmount,
+            });
+          } else {
+            // Add new
+            await addSubscription({
+              name: sub.name,
+              description: sub.description,
+              category: sub.category as any,
+              price: sub.price,
+              currency: sub.currency,
+              billingCycle: sub.billingCycle as any,
+              nextBillingDate: new Date(sub.nextBillingDate),
+              notificationsEnabled: sub.notificationsEnabled ?? true,
+              isCryptoEnabled: sub.isCryptoEnabled ?? false,
+              cryptoToken: sub.cryptoToken,
+              cryptoAmount: sub.cryptoAmount,
+            });
+          }
+        }
+      }
+
+      // Record in history
+      await recordImport('Manual Import', importMode, parsedData.length, result);
+
+      Alert.alert(
+        'Import Complete',
+        `Imported: ${result.imported}\nUpdated: ${result.updated}\nFailed: ${result.failed}`
+      );
+    } catch (error) {
+      Alert.alert(
+        'Error',
+        error instanceof Error ? error.message : 'Failed to complete import'
+      );
+    } finally {
+      setIsProcessing(false);
+    }
+  };
+
+  const loadHistory = useCallback(async () => {
+    const history = await getImportHistory();
+    setImportHistory(history);
+    setShowHistory(true);
+  }, []);
+
+  const clearData = useCallback(() => {
+    setImportText('');
+    setValidationResult(null);
+    setImportResult(null);
+  }, []);
+
+  const loadTemplate = useCallback((type: 'csv' | 'json') => {
+    setImportText(type === 'csv' ? getCSVTemplate() : getJSONTemplate());
+    setShowTemplateModal(false);
+  }, []);
+
+  const renderModeSelector = () => (
+    <View style={styles.modeContainer}>
+      <Text style={styles.sectionTitle}>Import Mode</Text>
+      <View style={styles.modeButtons}>
+        {(['create', 'upsert', 'replace'] as ImportMode[]).map((mode) => (
+          <TouchableOpacity
+            key={mode}
+            style={[
+              styles.modeButton,
+              importMode === mode && styles.modeButtonActive,
+            ]}
+            onPress={() => setImportMode(mode)}
+          >
+            <Text
+              style={[
+                styles.modeButtonText,
+                importMode === mode && styles.modeButtonTextActive,
+              ]}
+            >
+              {mode.charAt(0).toUpperCase() + mode.slice(1)}
+            </Text>
+          </TouchableOpacity>
+        ))}
+      </View>
+      <Text style={styles.modeDescription}>
+        {importMode === 'create'
+          ? 'Add new subscriptions only (skip duplicates)'
+          : importMode === 'upsert'
+          ? 'Update existing or add new subscriptions'
+          : 'Replace all existing subscriptions'}
+      </Text>
+    </View>
+  );
+
+  const renderValidationResults = () => {
+    if (!validationResult) return null;
+
+    return (
+      <Card style={styles.resultCard}>
+        <Text style={styles.resultTitle}>Validation Results</Text>
+        <View style={styles.resultRow}>
+          <Text style={styles.resultLabel}>Valid Rows:</Text>
+          <Text style={styles.resultValue}>{validationResult.validRows.length}</Text>
+        </View>
+        {validationResult.errors.length > 0 && (
+          <View style={styles.errorContainer}>
+            <Text style={styles.errorTitle}>Errors:</Text>
+            {validationResult.errors.slice(0, 5).map((error, index) => (
+              <Text key={index} style={styles.errorText}>
+                Row {error.row}: {error.message}
+              </Text>
+            ))}
+            {validationResult.errors.length > 5 && (
+              <Text style={styles.moreText}>
+                ...and {validationResult.errors.length - 5} more
+              </Text>
+            )}
+          </View>
+        )}
+        {validationResult.warnings.length > 0 && (
+          <View style={styles.warningContainer}>
+            <Text style={styles.warningTitle}>Warnings:</Text>
+            {validationResult.warnings.slice(0, 3).map((warning, index) => (
+              <Text key={index} style={styles.warningText}>
+                Row {warning.row}: {warning.message}
+              </Text>
+            ))}
+          </View>
+        )}
+      </Card>
+    );
+  };
+
+  const renderImportResults = () => {
+    if (!importResult) return null;
+
+    return (
+      <Card style={styles.resultCard}>
+        <Text style={styles.resultTitle}>Import Results</Text>
+        <View style={styles.resultRow}>
+          <Text style={styles.resultLabel}>Imported:</Text>
+          <Text style={[styles.resultValue, styles.successText]}>
+            {importResult.imported}
+          </Text>
+        </View>
+        <View style={styles.resultRow}>
+          <Text style={styles.resultLabel}>Updated:</Text>
+          <Text style={[styles.resultValue, styles.successText]}>
+            {importResult.updated}
+          </Text>
+        </View>
+        <View style={styles.resultRow}>
+          <Text style={styles.resultLabel}>Failed:</Text>
+          <Text style={[styles.resultValue, importResult.failed > 0 ? styles.errorText : styles.successText]}>
+            {importResult.failed}
+          </Text>
+        </View>
+      </Card>
+    );
+  };
+
+  const renderHistoryModal = () => (
+    <Modal
+      visible={showHistory}
+      animationType="slide"
+      presentationStyle="pageSheet"
+      onRequestClose={() => setShowHistory(false)}
+    >
+      <SafeAreaView style={styles.modalContainer}>
+        <View style={styles.modalHeader}>
+          <Text style={styles.modalTitle}>Import History</Text>
+          <TouchableOpacity onPress={() => setShowHistory(false)}>
+            <Text style={styles.closeButton}>Close</Text>
+          </TouchableOpacity>
+        </View>
+        <FlatList
+          data={importHistory}
+          keyExtractor={(item) => item.id}
+          renderItem={({ item }) => (
+            <Card style={styles.historyCard}>
+              <View style={styles.historyRow}>
+                <Text style={styles.historyFile}>{item.fileName}</Text>
+                <Text
+                  style={[
+                    styles.historyStatus,
+                    item.status === 'success' && styles.successText,
+                    item.status === 'partial' && styles.warningText,
+                    item.status === 'failed' && styles.errorText,
+                  ]}
+                >
+                  {item.status}
+                </Text>
+              </View>
+              <Text style={styles.historyDate}>
+                {new Date(item.timestamp).toLocaleString()}
+              </Text>
+              <Text style={styles.historyStats}>
+                Imported: {item.imported} | Updated: {item.updated} | Failed: {item.failed}
+              </Text>
+            </Card>
+          )}
+          ListEmptyComponent={
+            <Text style={styles.emptyText}>No import history</Text>
+          }
+        />
+      </SafeAreaView>
+    </Modal>
+  );
+
+  const renderTemplateModal = () => (
+    <Modal
+      visible={showTemplateModal}
+      animationType="slide"
+      presentationStyle="pageSheet"
+      onRequestClose={() => setShowTemplateModal(false)}
+    >
+      <SafeAreaView style={styles.modalContainer}>
+        <View style={styles.modalHeader}>
+          <Text style={styles.modalTitle}>Load Template</Text>
+          <TouchableOpacity onPress={() => setShowTemplateModal(false)}>
+            <Text style={styles.closeButton}>Close</Text>
+          </TouchableOpacity>
+        </View>
+        <View style={styles.templateButtons}>
+          <TouchableOpacity
+            style={styles.templateButton}
+            onPress={() => loadTemplate('csv')}
+          >
+            <Text style={styles.templateButtonText}>CSV Template</Text>
+            <Text style={styles.templateButtonSubtext}>
+              Sample CSV with column headers
+            </Text>
+          </TouchableOpacity>
+          <TouchableOpacity
+            style={styles.templateButton}
+            onPress={() => loadTemplate('json')}
+          >
+            <Text style={styles.templateButtonText}>JSON Template</Text>
+            <Text style={styles.templateButtonSubtext}>
+              Sample JSON export format
+            </Text>
+          </TouchableOpacity>
+        </View>
+      </SafeAreaView>
+    </Modal>
+  );
+
+  return (
+    <SafeAreaView style={styles.container}>
+      <ScrollView style={styles.scrollView}>
+        <View style={styles.header}>
+          <Text style={styles.title}>Import Subscriptions</Text>
+          <Text style={styles.subtitle}>
+            Import subscription data from CSV or JSON
+          </Text>
+        </View>
+
+        {renderModeSelector()}
+
+        <Card style={styles.inputCard}>
+          <View style={styles.inputHeader}>
+            <Text style={styles.sectionTitle}>Import Data</Text>
+            <TouchableOpacity onPress={() => setShowTemplateModal(true)}>
+              <Text style={styles.templateLink}>Load Template</Text>
+            </TouchableOpacity>
+          </View>
+          <TextInput
+            style={styles.textArea}
+            multiline
+            numberOfLines={10}
+            placeholder={`Paste your CSV or JSON data here...\n\nExample CSV:\nname,description,category,price,currency,billingCycle,nextBillingDate\nNetflix,Streaming,streaming,15.99,USD,monthly,2026-05-01`}
+            placeholderTextColor={colors.textSecondary}
+            value={importText}
+            onChangeText={setImportText}
+            textAlignVertical="top"
+          />
+        </Card>
+
+        {renderValidationResults()}
+        {renderImportResults()}
+
+        <View style={styles.buttonContainer}>
+          <Button
+            title={isProcessing ? 'Processing...' : 'Import Data'}
+            onPress={handleImport}
+            disabled={isProcessing || !importText.trim()}
+            loading={isProcessing}
+          />
+          <Button
+            title="Clear"
+            onPress={clearData}
+            variant="secondary"
+            disabled={isProcessing || !importText}
+          />
+        </View>
+
+        <TouchableOpacity style={styles.historyLink} onPress={loadHistory}>
+          <Text style={styles.historyLinkText}>View Import History</Text>
+        </TouchableOpacity>
+      </ScrollView>
+
+      {renderHistoryModal()}
+      {renderTemplateModal()}
+    </SafeAreaView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: colors.background,
+  },
+  scrollView: {
+    flex: 1,
+  },
+  header: {
+    padding: spacing.lg,
+    paddingTop: spacing.xl,
+  },
+  title: {
+    ...typography.h1,
+    color: colors.text,
+  },
+  subtitle: {
+    ...typography.body,
+    color: colors.textSecondary,
+    marginTop: spacing.xs,
+  },
+  modeContainer: {
+    padding: spacing.lg,
+    paddingTop: 0,
+  },
+  modeButtons: {
+    flexDirection: 'row',
+    marginTop: spacing.md,
+    gap: spacing.sm,
+  },
+  modeButton: {
+    flex: 1,
+    padding: spacing.md,
+    borderRadius: borderRadius.md,
+    borderWidth: 1,
+    borderColor: colors.border,
+    alignItems: 'center',
+  },
+  modeButtonActive: {
+    backgroundColor: colors.primary,
+    borderColor: colors.primary,
+  },
+  modeButtonText: {
+    ...typography.body,
+    color: colors.text,
+    fontWeight: '600',
+  },
+  modeButtonTextActive: {
+    color: colors.textInverted,
+  },
+  modeDescription: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    marginTop: spacing.sm,
+  },
+  sectionTitle: {
+    ...typography.h3,
+    color: colors.text,
+  },
+  inputCard: {
+    margin: spacing.lg,
+    marginTop: 0,
+  },
+  inputHeader: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+    marginBottom: spacing.md,
+  },
+  templateLink: {
+    ...typography.body,
+    color: colors.primary,
+    fontWeight: '600',
+  },
+  textArea: {
+    ...typography.body,
+    minHeight: 200,
+    borderWidth: 1,
+    borderColor: colors.border,
+    borderRadius: borderRadius.md,
+    padding: spacing.md,
+    color: colors.text,
+    backgroundColor: colors.surface,
+  },
+  buttonContainer: {
+    padding: spacing.lg,
+    paddingTop: 0,
+    gap: spacing.md,
+  },
+  resultCard: {
+    margin: spacing.lg,
+    marginTop: spacing.md,
+  },
+  resultTitle: {
+    ...typography.h3,
+    color: colors.text,
+    marginBottom: spacing.md,
+  },
+  resultRow: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    marginBottom: spacing.sm,
+  },
+  resultLabel: {
+    ...typography.body,
+    color: colors.textSecondary,
+  },
+  resultValue: {
+    ...typography.body,
+    color: colors.text,
+    fontWeight: '600',
+  },
+  successText: {
+    color: colors.success,
+  },
+  errorText: {
+    color: colors.error,
+  },
+  warningText: {
+    color: colors.warning,
+  },
+  errorContainer: {
+    marginTop: spacing.md,
+    padding: spacing.md,
+    backgroundColor: colors.error + '20',
+    borderRadius: borderRadius.md,
+  },
+  errorTitle: {
+    ...typography.body,
+    color: colors.error,
+    fontWeight: '600',
+    marginBottom: spacing.sm,
+  },
+  warningContainer: {
+    marginTop: spacing.md,
+    padding: spacing.md,
+    backgroundColor: colors.warning + '20',
+    borderRadius: borderRadius.md,
+  },
+  warningTitle: {
+    ...typography.body,
+    color: colors.warning,
+    fontWeight: '600',
+    marginBottom: spacing.sm,
+  },
+  errorText: {
+    ...typography.caption,
+    color: colors.error,
+  },
+  warningText: {
+    ...typography.caption,
+    color: colors.warning,
+  },
+  moreText: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    fontStyle: 'italic',
+    marginTop: spacing.sm,
+  },
+  historyLink: {
+    alignItems: 'center',
+    padding: spacing.lg,
+  },
+  historyLinkText: {
+    ...typography.body,
+    color: colors.primary,
+  },
+  modalContainer: {
+    flex: 1,
+    backgroundColor: colors.background,
+  },
+  modalHeader: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+    padding: spacing.lg,
+    borderBottomWidth: 1,
+    borderBottomColor: colors.border,
+  },
+  modalTitle: {
+    ...typography.h2,
+    color: colors.text,
+  },
+  closeButton: {
+    ...typography.body,
+    color: colors.primary,
+    fontWeight: '600',
+  },
+  historyCard: {
+    margin: spacing.md,
+  },
+  historyRow: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+  },
+  historyFile: {
+    ...typography.body,
+    color: colors.text,
+    fontWeight: '600',
+  },
+  historyStatus: {
+    ...typography.caption,
+    fontWeight: '600',
+    textTransform: 'capitalize',
+  },
+  historyDate: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    marginTop: spacing.xs,
+  },
+  historyStats: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    marginTop: spacing.xs,
+  },
+  emptyText: {
+    ...typography.body,
+    color: colors.textSecondary,
+    textAlign: 'center',
+    marginTop: spacing.xl,
+  },
+  templateButtons: {
+    padding: spacing.lg,
+  },
+  templateButton: {
+    padding: spacing.lg,
+    backgroundColor: colors.surface,
+    borderRadius: borderRadius.md,
+    marginBottom: spacing.md,
+    borderWidth: 1,
+    borderColor: colors.border,
+  },
+  templateButtonText: {
+    ...typography.h3,
+    color: colors.text,
+  },
+  templateButtonSubtext: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    marginTop: spacing.xs,
+  },
+});
+
+export default ImportScreen;
\ No newline at end of file
diff --git a/src/screens/SettingsScreen.tsx b/src/screens/SettingsScreen.tsx
index f51dc82..a82c1e1 100644
--- a/src/screens/SettingsScreen.tsx
+++ b/src/screens/SettingsScreen.tsx
@@ -191,6 +191,28 @@ const SettingsScreen: React.FC = () => {
           </View>
         </Card>
         <Card style={styles.section}>
+          <Text style={styles.sectionTitle} accessibilityRole="header">Data Management</Text>
+          <TouchableOpacity
+            style={styles.linkRow}
+            onPress={() => navigation.navigate('Import')}
+            accessibilityRole="button"
+            accessibilityLabel="Import subscriptions"
+            accessibilityHint="Opens import screen">
+            <Text style={styles.linkText}>Import Subscriptions</Text>
+            <Text style={styles.linkArrow} accessibilityElementsHidden={true}>→</Text>
+          </TouchableOpacity>
+          <TouchableOpacity
+            style={styles.linkRow}
+            onPress={() => navigation.navigate('Export')}
+            accessibilityRole="button"
+            accessibilityLabel="Export subscriptions"
+            accessibilityHint="Opens export screen">
+            <Text style={styles.linkText}>Export Subscriptions</Text>
+            <Text style={styles.linkArrow} accessibilityElementsHidden={true}>→</Text>
+          </TouchableOpacity>
+        </Card>
+        <Card style={styles.section}>
+          <Text style={styles.sectionTitle} accessibilityRole="header">About</Text>
           <Text style={styles.sectionTitle} accessibilityRole="header">
             {t('settings.sections.about')}
           </Text>
diff --git a/src/store/disputeStore.ts b/src/store/disputeStore.ts
new file mode 100644
index 0000000..d9ba88f
--- /dev/null
+++ b/src/store/disputeStore.ts
@@ -0,0 +1,681 @@
+import { create } from 'zustand';
+import { persist, createJSONStorage, StateStorage } from 'zustand/middleware';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { CACHE_CONSTANTS } from '../utils/constants/values';
+import { errorHandler, AppError } from '../services/errorHandler';
+
+const STORAGE_KEY = 'subtrackr-disputes';
+const STORE_VERSION = 1;
+const WRITE_DEBOUNCE_MS = CACHE_CONSTANTS.WRITE_DEBOUNCE_MS;
+
+// ════════════════════════════════════════════════════════════════
+// TYPES
+// ════════════════════════════════════════════════════════════════
+
+export enum DisputeStatus {
+  /** Dispute has been created but not yet submitted */
+  Pending = 'pending',
+  /** Evidence is being collected */
+  GatheringEvidence = 'gathering_evidence',
+  /** Evidence submitted, awaiting review */
+  UnderReview = 'under_review',
+  /** Awaiting manual review decision */
+  AwaitingManualReview = 'awaiting_manual_review',
+  /** Dispute has been resolved */
+  Resolved = 'resolved',
+  /** Dispute was rejected */
+  Rejected = 'rejected',
+  /** Dispute expired due to time limit */
+  Expired = 'expired',
+}
+
+export enum DisputeReason {
+  /** Product/service not as described */
+  NotAsDescribed = 'not_as_described',
+  /** Product/service not received */
+  NotReceived = 'not_received',
+  /** Unauthorized charge */
+  Unauthorized = 'unauthorized',
+  /** Duplicate charge */
+  Duplicate = 'duplicate',
+  /** Incorrect amount charged */
+  IncorrectAmount = 'incorrect_amount',
+  /** Subscription cancelled but charged */
+  CancelledSubscription = 'cancelled_subscription',
+  /** Refund not processed */
+  RefundNotProcessed = 'refund_not_processed',
+  /** Other reason */
+  Other = 'other',
+}
+
+export enum Resolution {
+  /** Dispute won - customer gets refund */
+  Refund = 'refund',
+  /** Original charge upheld - no refund */
+  Upheld = 'upheld',
+  /** Partial refund granted */
+  PartialRefund = 'partial_refund',
+  /** Counter-claim successful */
+  Counter = 'counter',
+  /** Settlement reached between parties */
+  Settlement = 'settlement',
+}
+
+export enum EvidenceType {
+  /** Proof of delivery */
+  ProofOfDelivery = 'proof_of_delivery',
+  /** Communication records */
+  Communication = 'communication',
+  /** Contract/terms documentation */
+  Contract = 'contract',
+  /** Receipt or invoice */
+  Receipt = 'receipt',
+  /** Product/service description */
+  ProductDescription = 'product_description',
+  /** Customer interaction history */
+  InteractionHistory = 'interaction_history',
+  /** Other evidence */
+  Other = 'other',
+}
+
+export interface Evidence {
+  /** Unique evidence ID */
+  id: string;
+  /** Type of evidence */
+  evidenceType: EvidenceType;
+  /** Description of the evidence */
+  description: string;
+  /** URL or reference to evidence file */
+  reference: string;
+  /** Timestamp when evidence was submitted */
+  submittedAt: Date;
+  /** Who submitted the evidence */
+  submittedBy: string;
+}
+
+export interface TimelineEvent {
+  /** Event ID */
+  id: string;
+  /** Event type */
+  eventType: TimelineEventType;
+  /** Description of the event */
+  description: string;
+  /** Timestamp of the event */
+  timestamp: Date;
+  /** Who triggered the event */
+  triggeredBy: string;
+}
+
+export enum TimelineEventType {
+  Created = 'created',
+  EvidenceSubmitted = 'evidence_submitted',
+  StatusChanged = 'status_changed',
+  ManualReviewRequested = 'manual_review_requested',
+  Resolved = 'resolved',
+  Expired = 'expired',
+}
+
+export interface Dispute {
+  /** Unique dispute identifier */
+  id: string;
+  /** Charge ID this dispute is related to */
+  chargeId: string;
+  /** Subscription ID (if applicable) */
+  subscriptionId?: string;
+  /** Subscription name for display */
+  subscriptionName?: string;
+  /** User who created the dispute */
+  userId: string;
+  /** Reason for the dispute */
+  reason: DisputeReason;
+  /** Current status of the dispute */
+  status: DisputeStatus;
+  /** Evidence submitted for this dispute */
+  evidence: Evidence[];
+  /** Timeline events */
+  timeline: TimelineEvent[];
+  /** Resolution (if resolved) */
+  resolution?: Resolution;
+  /** Resolution notes */
+  resolutionNotes?: string;
+  /** When the dispute was created */
+  createdAt: Date;
+  /** When the dispute was last updated */
+  updatedAt: Date;
+  /** Deadline for submitting evidence */
+  evidenceDeadline: Date;
+  /** Resolution timestamp (if resolved) */
+  resolvedAt?: Date;
+  /** Amount in dispute */
+  amount: number;
+  /** Currency */
+  currency: string;
+}
+
+export interface DisputeAnalytics {
+  /** Total disputes filed */
+  totalDisputes: number;
+  /** Disputes won (refund) */
+  disputesWon: number;
+  /** Disputes lost (upheld) */
+  disputesLost: number;
+  /** Disputes settled */
+  disputesSettled: number;
+  /** Pending disputes */
+  pendingDisputes: number;
+  /** Average resolution time in seconds */
+  avgResolutionTime: number;
+  /** Total amount disputed */
+  totalAmountDisputed: number;
+  /** Total amount refunded */
+  totalAmountRefunded: number;
+  /** Disputes by status */
+  disputesByStatus: Record<DisputeStatus, number>;
+  /** Disputes by reason */
+  disputesByReason: Record<DisputeReason, number>;
+}
+
+export interface DisputeFormData {
+  chargeId: string;
+  subscriptionId?: string;
+  reason: DisputeReason;
+  description?: string;
+  amount: number;
+  currency: string;
+}
+
+export interface EvidenceFormData {
+  evidenceType: EvidenceType;
+  description: string;
+  reference: string;
+}
+
+// ════════════════════════════════════════════════════════════════
+// STATE INTERFACE
+// ════════════════════════════════════════════════════════════════
+
+interface DisputeState {
+  // State
+  disputes: Dispute[];
+  analytics: DisputeAnalytics;
+  selectedDisputeId: string | null;
+  isLoading: boolean;
+  error: string | null;
+
+  // Actions
+  createDispute: (data: DisputeFormData, userId: string) => Promise<Dispute>;
+  submitEvidence: (disputeId: string, evidence: EvidenceFormData, userId: string) => Promise<void>;
+  requestManualReview: (disputeId: string, userId: string) => Promise<void>;
+  resolveDispute: (disputeId: string, resolution: Resolution, notes?: string, resolverId?: string) => Promise<void>;
+  getDispute: (disputeId: string) => Dispute | undefined;
+  getDisputesBySubscription: (subscriptionId: string) => Dispute[];
+  getDisputesByUser: (userId: string) => Dispute[];
+  getDisputesByStatus: (status: DisputeStatus) => Dispute[];
+  selectDispute: (disputeId: string | null) => void;
+  updateAnalytics: () => void;
+  deleteDispute: (disputeId: string) => Promise<void>;
+  clearError: () => void;
+}
+
+// ════════════════════════════════════════════════════════════════
+// HELPERS
+// ════════════════════════════════════════════════════════════════
+
+const generateUniqueId = (): string => {
+  const timestamp = Date.now().toString(36);
+  const randomComponent = Math.random().toString(36).substring(2, 8);
+  return `disp-${timestamp}-${randomComponent}`;
+};
+
+const generateEvidenceId = (): string => {
+  const timestamp = Date.now().toString(36);
+  const randomComponent = Math.random().toString(36).substring(2, 8);
+  return `ev-${timestamp}-${randomComponent}`;
+};
+
+const toValidDate = (value: unknown, fallback = new Date()): Date => {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+  if (typeof value === 'string' || typeof value.isFinite) {
+    const parsed = new Date(value as string);
+    if (!Number.isNaN(parsed.getTime())) return parsed;
+  }
+  return fallback;
+};
+
+const normalizeDispute = (raw: Partial<Dispute>): Dispute => {
+  const now = new Date();
+  const evidenceDeadline = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000); // 7 days
+
+  return {
+    id: raw.id ?? generateUniqueId(),
+    chargeId: raw.chargeId ?? '',
+    subscriptionId: raw.subscriptionId,
+    subscriptionName: raw.subscriptionName,
+    userId: raw.userId ?? '',
+    reason: raw.reason ?? DisputeReason.Other,
+    status: raw.status ?? DisputeStatus.Pending,
+    evidence: Array.isArray(raw.evidence) ? raw.evidence : [],
+    timeline: Array.isArray(raw.timeline) ? raw.timeline : [],
+    resolution: raw.resolution,
+    resolutionNotes: raw.resolutionNotes,
+    createdAt: toValidDate(raw.createdAt, now),
+    updatedAt: toValidDate(raw.updatedAt, now),
+    evidenceDeadline: toValidDate(raw.evidenceDeadline, evidenceDeadline),
+    resolvedAt: raw.resolvedAt ? toValidDate(raw.resolvedAt) : undefined,
+    amount: Number.isFinite(raw.amount) ? (raw.amount as number) : 0,
+    currency: raw.currency ?? 'USD',
+  };
+};
+
+const defaultAnalytics: DisputeAnalytics = {
+  totalDisputes: 0,
+  disputesWon: 0,
+  disputesLost: 0,
+  disputesSettled: 0,
+  pendingDisputes: 0,
+  avgResolutionTime: 0,
+  totalAmountDisputed: 0,
+  totalAmountRefunded: 0,
+  disputesByStatus: {} as Record<DisputeStatus, number>,
+  disputesByReason: {} as Record<DisputeReason, number>,
+};
+
+// Initialize analytics with all statuses and reasons
+Object.values(DisputeStatus).forEach((status) => {
+  defaultAnalytics.disputesByStatus[status] = 0;
+});
+Object.values(DisputeReason).forEach((reason) => {
+  defaultAnalytics.disputesByReason[reason] = 0;
+});
+
+const serializeForStorage = (state: Pick<DisputeState, 'disputes' | 'analytics'>): Pick<DisputeState, 'disputes' | 'analytics'> => ({
+  disputes: state.disputes.map((dispute) => ({
+    ...dispute,
+    createdAt: new Date(dispute.createdAt),
+    updatedAt: new Date(dispute.updatedAt),
+    evidenceDeadline: new Date(dispute.evidenceDeadline),
+    resolvedAt: dispute.resolvedAt ? new Date(dispute.resolvedAt) : undefined,
+    evidence: dispute.evidence.map((ev) => ({
+      ...ev,
+      submittedAt: new Date(ev.submittedAt),
+    })),
+    timeline: dispute.timeline.map((event) => ({
+      ...event,
+      timestamp: new Date(event.timestamp),
+    })),
+  })),
+  analytics: state.analytics,
+});
+
+const migratePersistedState = (persisted: unknown): Pick<DisputeState, 'disputes' | 'analytics'> => {
+  if (!persisted || typeof persisted !== 'object') {
+    return { disputes: [], analytics: defaultAnalytics };
+  }
+
+  const maybeState = persisted as Partial<Pick<DisputeState, 'disputes' | 'analytics'>>;
+  const disputes = Array.isArray(maybeState.disputes)
+    ? maybeState.disputes.map((entry) => normalizeDispute(entry as Partial<Dispute>))
+    : [];
+
+  return {
+    disputes,
+    analytics: maybeState.analytics ?? defaultAnalytics,
+  };
+};
+
+const pendingWrites = new Map<string, string>();
+let writeTimer: ReturnType<typeof setTimeout> | null = null;
+let writeQueue = Promise.resolve();
+
+const flushPendingWrites = async (): Promise<void> => {
+  const entries = Array.from(pendingWrites.entries());
+  pendingWrites.clear();
+
+  for (const [, serialized] of entries) {
+    try {
+      await AsyncStorage.setItem(STORAGE_KEY, serialized);
+    } catch (error) {
+      console.error('Failed to persist disputes:', error);
+    }
+  }
+};
+
+const scheduleWrite = (state: Pick<DisputeState, 'disputes' | 'analytics'>): void => {
+  const serialized = JSON.stringify(serializeForStorage(state));
+  const key = `disputes-${Date.now()}`;
+  pendingWrites.set(key, serialized);
+
+  if (writeTimer) {
+    clearTimeout(writeTimer);
+  }
+
+  writeTimer = setTimeout(() => {
+    writeQueue = writeQueue.then(flushPendingWrites);
+  }, WRITE_DEBOUNCE_MS);
+};
+
+// ════════════════════════════════════════════════════════════════
+// STORE
+// ════════════════════════════════════════════════════════════════
+
+export const useDisputeStore = create<DisputeState>()(
+  persist(
+    (set, get) => ({
+      // Initial state
+      disputes: [],
+      analytics: defaultAnalytics,
+      selectedDisputeId: null,
+      isLoading: false,
+      error: null,
+
+      // Create a new dispute
+      createDispute: async (data: DisputeFormData, userId: string): Promise<Dispute> => {
+        const now = new Date();
+        const evidenceDeadline = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
+
+        const dispute: Dispute = {
+          id: generateUniqueId(),
+          chargeId: data.chargeId,
+          subscriptionId: data.subscriptionId,
+          userId,
+          reason: data.reason,
+          status: DisputeStatus.Pending,
+          evidence: [],
+          timeline: [
+            {
+              id: generateUniqueId(),
+              eventType: TimelineEventType.Created,
+              description: `Dispute created for charge ${data.chargeId}`,
+              timestamp: now,
+              triggeredBy: userId,
+            },
+          ],
+          createdAt: now,
+          updatedAt: now,
+          evidenceDeadline,
+          amount: data.amount,
+          currency: data.currency,
+        };
+
+        set((state) => {
+          const newState = {
+            ...state,
+            disputes: [...state.disputes, dispute],
+          };
+          scheduleWrite(newState);
+          return newState;
+        });
+
+        // Update analytics
+        get().updateAnalytics();
+
+        return dispute;
+      },
+
+      // Submit evidence for a dispute
+      submitEvidence: async (disputeId: string, evidence: EvidenceFormData, userId: string): Promise<void> => {
+        const now = new Date();
+
+        set((state) => {
+          const disputes = state.disputes.map((dispute) => {
+            if (dispute.id === disputeId) {
+              // Check if dispute is still active
+              if (
+                dispute.status === DisputeStatus.Resolved ||
+                dispute.status === DisputeStatus.Rejected ||
+                dispute.status === DisputeStatus.Expired
+              ) {
+                throw new Error('Cannot submit evidence to resolved dispute');
+              }
+
+              // Check evidence deadline
+              if (now > dispute.evidenceDeadline) {
+                throw new Error('Evidence submission deadline passed');
+              }
+
+              // Check max evidence limit
+              if (dispute.evidence.length >= 20) {
+                throw new Error('Maximum evidence limit reached');
+              }
+
+              const newEvidence: Evidence = {
+                id: generateEvidenceId(),
+                evidenceType: evidence.evidenceType,
+                description: evidence.description,
+                reference: evidence.reference,
+                submittedAt: now,
+                submittedBy: userId,
+              };
+
+              return {
+                ...dispute,
+                evidence: [...dispute.evidence, newEvidence],
+                status: DisputeStatus.GatheringEvidence,
+                updatedAt: now,
+                timeline: [
+                  ...dispute.timeline,
+                  {
+                    id: generateUniqueId(),
+                    eventType: TimelineEventType.EvidenceSubmitted,
+                    description: `Evidence submitted: ${evidence.description}`,
+                    timestamp: now,
+                    triggeredBy: userId,
+                  },
+                ],
+              };
+            }
+            return dispute;
+          });
+
+          const newState = { ...state, disputes };
+          scheduleWrite(newState);
+          return newState;
+        });
+      },
+
+      // Request manual review
+      requestManualReview: async (disputeId: string, userId: string): Promise<void> => {
+        const now = new Date();
+
+        set((state) => {
+          const disputes = state.disputes.map((dispute) => {
+            if (dispute.id === disputeId) {
+              if (
+                dispute.status === DisputeStatus.Resolved ||
+                dispute.status === DisputeStatus.Rejected ||
+                dispute.status === DisputeStatus.Expired
+              ) {
+                throw new Error('Cannot request review for resolved dispute');
+              }
+
+              return {
+                ...dispute,
+                status: DisputeStatus.AwaitingManualReview,
+                updatedAt: now,
+                timeline: [
+                  ...dispute.timeline,
+                  {
+                    id: generateUniqueId(),
+                    eventType: TimelineEventType.ManualReviewRequested,
+                    description: 'Manual review requested',
+                    timestamp: now,
+                    triggeredBy: userId,
+                  },
+                ],
+              };
+            }
+            return dispute;
+          });
+
+          const newState = { ...state, disputes };
+          scheduleWrite(newState);
+          return newState;
+        });
+      },
+
+      // Resolve a dispute
+      resolveDispute: async (
+        disputeId: string,
+        resolution: Resolution,
+        notes?: string,
+        resolverId?: string
+      ): Promise<void> => {
+        const now = new Date();
+
+        set((state) => {
+          const disputes = state.disputes.map((dispute) => {
+            if (dispute.id === disputeId) {
+              if (
+                dispute.status === DisputeStatus.Resolved ||
+                dispute.status === DisputeStatus.Rejected ||
+                dispute.status === DisputeStatus.Expired
+              ) {
+                throw new Error('Dispute already resolved');
+              }
+
+              return {
+                ...dispute,
+                status: DisputeStatus.Resolved,
+                resolution,
+                resolutionNotes: notes,
+                resolvedAt: now,
+                updatedAt: now,
+                timeline: [
+                  ...dispute.timeline,
+                  {
+                    id: generateUniqueId(),
+                    eventType: TimelineEventType.Resolved,
+                    description: `Dispute resolved: ${resolution}`,
+                    timestamp: now,
+                    triggeredBy: resolverId ?? 'system',
+                  },
+                ],
+              };
+            }
+            return dispute;
+          });
+
+          const newState = { ...state, disputes };
+          scheduleWrite(newState);
+          return newState;
+        });
+
+        // Update analytics
+        get().updateAnalytics();
+      },
+
+      // Get a specific dispute
+      getDispute: (disputeId: string): Dispute | undefined => {
+        return get().disputes.find((d) => d.id === disputeId);
+      },
+
+      // Get disputes by subscription
+      getDisputesBySubscription: (subscriptionId: string): Dispute[] => {
+        return get().disputes.filter((d) => d.subscriptionId === subscriptionId);
+      },
+
+      // Get disputes by user
+      getDisputesByUser: (userId: string): Dispute[] => {
+        return get().disputes.filter((d) => d.userId === userId);
+      },
+
+      // Get disputes by status
+      getDisputesByStatus: (status: DisputeStatus): Dispute[] => {
+        return get().disputes.filter((d) => d.status === status);
+      },
+
+      // Select a dispute
+      selectDispute: (disputeId: string | null): void => {
+        set({ selectedDisputeId: disputeId });
+      },
+
+      // Update analytics
+      updateAnalytics: (): void => {
+        const { disputes } = get();
+
+        const analytics: DisputeAnalytics = {
+          ...defaultAnalytics,
+          totalDisputes: disputes.length,
+          disputesByStatus: { ...defaultAnalytics.disputesByStatus },
+          disputesByReason: { ...defaultAnalytics.disputesByReason },
+        };
+
+        let totalResolutionTime = 0;
+        let resolvedCount = 0;
+
+        disputes.forEach((dispute) => {
+          // Count by status
+          analytics.disputesByStatus[dispute.status] =
+            (analytics.disputesByStatus[dispute.status] ?? 0) + 1;
+
+          // Count by reason
+          analytics.disputesByReason[dispute.reason] =
+            (analytics.disputesByReason[dispute.reason] ?? 0) + 1;
+
+          // Track amounts
+          analytics.totalAmountDisputed += dispute.amount;
+
+          if (dispute.resolution === Resolution.Refund) {
+            analytics.disputesWon += 1;
+            analytics.totalAmountRefunded += dispute.amount;
+          } else if (dispute.resolution === Resolution.Upheld) {
+            analytics.disputesLost += 1;
+          } else if (dispute.resolution === Resolution.Settlement) {
+            analytics.disputesSettled += 1;
+          } else if (dispute.resolution === Resolution.PartialRefund) {
+            analytics.disputesWon += 1;
+            analytics.disputesSettled += 1;
+            analytics.totalAmountRefunded += dispute.amount * 0.5;
+          }
+
+          // Calculate resolution time
+          if (dispute.resolvedAt) {
+            const resolutionTime = dispute.resolvedAt.getTime() - dispute.createdAt.getTime();
+            totalResolutionTime += resolutionTime;
+            resolvedCount += 1;
+          }
+        });
+
+        analytics.pendingDisputes =
+          (analytics.disputesByStatus[DisputeStatus.Pending] ?? 0) +
+          (analytics.disputesByStatus[DisputeStatus.GatheringEvidence] ?? 0) +
+          (analytics.disputesByStatus[DisputeStatus.UnderReview] ?? 0) +
+          (analytics.disputesByStatus[DisputeStatus.AwaitingManualReview] ?? 0);
+
+        analytics.avgResolutionTime = resolvedCount > 0 ? totalResolutionTime / resolvedCount : 0;
+
+        set({ analytics });
+      },
+
+      // Delete a dispute
+      deleteDispute: async (disputeId: string): Promise<void> => {
+        set((state) => {
+          const disputes = state.disputes.filter((d) => d.id !== disputeId);
+          const newState = { ...state, disputes };
+          scheduleWrite(newState);
+          return newState;
+        });
+
+        get().updateAnalytics();
+      },
+
+      // Clear error
+      clearError: (): void => {
+        set({ error: null });
+      },
+    }),
+    {
+      name: STORAGE_KEY,
+      storage: createJSONStorage(() => AsyncStorage),
+      version: STORE_VERSION,
+      migrate: migratePersistedState,
+      partialize: (state) => ({
+        disputes: state.disputes,
+        analytics: state.analytics,
+      }),
+    }
+  )
+);
+
+// Initialize analytics on load
+useDisputeStore.getState().updateAnalytics();
\ No newline at end of file
diff --git a/src/store/index.ts b/src/store/index.ts
index 608012e..137ebeb 100644
--- a/src/store/index.ts
+++ b/src/store/index.ts
@@ -5,3 +5,16 @@ export { useWalletStore } from './walletStore';
 export { useNetworkStore } from './networkStore';
 export { useCommunityStore } from './communityStore';
 export { useAccountingStore } from './accountingStore';
+export { useDisputeStore } from './disputeStore';
+export {
+  DisputeStatus,
+  DisputeReason,
+  Resolution,
+  EvidenceType,
+  type Dispute,
+  type DisputeAnalytics,
+  type DisputeFormData,
+  type EvidenceFormData,
+  type Evidence,
+  type TimelineEvent,
+} from './disputeStore';
diff --git a/src/utils/__tests__/importExport.test.ts b/src/utils/__tests__/importExport.test.ts
new file mode 100644
index 0000000..63502bc
--- /dev/null
+++ b/src/utils/__tests__/importExport.test.ts
@@ -0,0 +1,391 @@
+/**
+ * Import/Export Tests
+ */
+
+import {
+  parseCSV,
+  parseJSON,
+  generateCSV,
+  exportToJSON,
+  validateImport,
+  processImport,
+  detectFormat,
+  getCSVTemplate,
+  getJSONTemplate,
+  ImportMode,
+  Subscription,
+  SubscriptionCategory,
+  BillingCycle,
+} from '../utils/importExport';
+
+describe('Import/Export Utilities', () => {
+  describe('CSV Parsing', () => {
+    it('should parse valid CSV data', () => {
+      const csv = `name,description,category,price,currency,billingCycle,nextBillingDate
+Netflix,Streaming service,streaming,15.99,USD,monthly,2026-05-01
+Spotify,Music streaming,streaming,9.99,USD,monthly,2026-05-15`;
+
+      const result = parseCSV(csv);
+      expect(result).toHaveLength(2);
+      expect(result[0].name).toBe('Netflix');
+      expect(result[0].price).toBe(15.99);
+      expect(result[1].name).toBe('Spotify');
+    });
+
+    it('should handle quoted values with commas', () => {
+      const csv = `name,description,category,price,currency,billingCycle,nextBillingDate
+Netflix,"Premium, 4K",streaming,15.99,USD,monthly,2026-05-01`;
+
+      const result = parseCSV(csv);
+      expect(result).toHaveLength(1);
+      expect(result[0].description).toBe('Premium, 4K');
+    });
+
+    it('should throw error for empty CSV', () => {
+      expect(() => parseCSV('')).toThrow('CSV must contain at least a header row and one data row');
+    });
+
+    it('should skip empty rows', () => {
+      const csv = `name,description,category,price,currency,billingCycle,nextBillingDate
+Netflix,Streaming service,streaming,15.99,USD,monthly,2026-05-01
+
+Spotify,Music streaming,streaming,9.99,USD,monthly,2026-05-15`;
+
+      const result = parseCSV(csv);
+      expect(result).toHaveLength(2);
+    });
+  });
+
+  describe('JSON Parsing', () => {
+    it('should parse JSON array', () => {
+      const json = `[
+        {
+          "name": "Netflix",
+          "category": "streaming",
+          "price": 15.99,
+          "currency": "USD",
+          "billingCycle": "monthly",
+          "nextBillingDate": "2026-05-01"
+        }
+      ]`;
+
+      const result = parseJSON(json);
+      expect(result).toHaveLength(1);
+      expect(result[0].name).toBe('Netflix');
+    });
+
+    it('should parse export format with metadata', () => {
+      const json = `{
+        "version": "1.0.0",
+        "exportedAt": "2026-04-26T00:00:00.000Z",
+        "subscriptionCount": 1,
+        "subscriptions": [
+          {
+            "name": "Netflix",
+            "category": "streaming",
+            "price": 15.99,
+            "currency": "USD",
+            "billingCycle": "monthly",
+            "nextBillingDate": "2026-05-01"
+          }
+        ]
+      }`;
+
+      const result = parseJSON(json);
+      expect(result).toHaveLength(1);
+      expect(result[0].name).toBe('Netflix');
+    });
+
+    it('should throw error for invalid JSON', () => {
+      expect(() => parseJSON('not valid json')).toThrow();
+    });
+  });
+
+  describe('CSV Generation', () => {
+    it('should generate valid CSV from subscriptions', () => {
+      const subscriptions: Subscription[] = [
+        {
+          id: '1',
+          name: 'Netflix',
+          description: 'Streaming service',
+          category: SubscriptionCategory.STREAMING,
+          price: 15.99,
+          currency: 'USD',
+          billingCycle: BillingCycle.MONTHLY,
+          nextBillingDate: new Date('2026-05-01'),
+          isActive: true,
+          notificationsEnabled: true,
+          isCryptoEnabled: false,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      const csv = generateCSV(subscriptions);
+      expect(csv).toContain('Netflix');
+      expect(csv).toContain('15.99');
+      expect(csv).toContain('USD');
+    });
+
+    it('should handle special characters in CSV', () => {
+      const subscriptions: Subscription[] = [
+        {
+          id: '1',
+          name: 'Test "quoted" subscription',
+          description: 'Description with, comma',
+          category: SubscriptionCategory.OTHER,
+          price: 10,
+          currency: 'USD',
+          billingCycle: BillingCycle.MONTHLY,
+          nextBillingDate: new Date('2026-05-01'),
+          isActive: true,
+          notificationsEnabled: true,
+          isCryptoEnabled: false,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      const csv = generateCSV(subscriptions);
+      expect(csv).toContain('"Test ""quoted"" subscription"');
+    });
+  });
+
+  describe('JSON Export', () => {
+    it('should export subscriptions to JSON', () => {
+      const subscriptions: Subscription[] = [
+        {
+          id: '1',
+          name: 'Netflix',
+          category: SubscriptionCategory.STREAMING,
+          price: 15.99,
+          currency: 'USD',
+          billingCycle: BillingCycle.MONTHLY,
+          nextBillingDate: new Date('2026-05-01'),
+          isActive: true,
+          notificationsEnabled: true,
+          isCryptoEnabled: false,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      const json = exportToJSON(subscriptions);
+      const parsed = JSON.parse(json);
+      
+      expect(parsed.version).toBe('1.0.0');
+      expect(parsed.subscriptionCount).toBe(1);
+      expect(parsed.subscriptions[0].name).toBe('Netflix');
+    });
+  });
+
+  describe('Validation', () => {
+    it('should validate correct data', () => {
+      const data = {
+        subscriptions: [
+          {
+            name: 'Netflix',
+            category: 'streaming',
+            price: 15.99,
+            currency: 'USD',
+            billingCycle: 'monthly',
+            nextBillingDate: '2026-05-01',
+          },
+        ],
+        mode: 'create' as ImportMode,
+      };
+
+      const result = validateImport(data);
+      expect(result.isValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should catch missing required fields', () => {
+      const data = {
+        subscriptions: [
+          {
+            name: '',
+            category: 'streaming',
+            price: 15.99,
+            currency: 'USD',
+            billingCycle: 'monthly',
+            nextBillingDate: '2026-05-01',
+          },
+        ],
+        mode: 'create' as ImportMode,
+      };
+
+      const result = validateImport(data);
+      expect(result.isValid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+
+    it('should catch invalid price', () => {
+      const data = {
+        subscriptions: [
+          {
+            name: 'Netflix',
+            category: 'streaming',
+            price: -10,
+            currency: 'USD',
+            billingCycle: 'monthly',
+            nextBillingDate: '2026-05-01',
+          },
+        ],
+        mode: 'create' as ImportMode,
+      };
+
+      const result = validateImport(data);
+      expect(result.isValid).toBe(false);
+      expect(result.errors.some(e => e.field === 'price')).toBe(true);
+    });
+
+    it('should add warnings for invalid category', () => {
+      const data = {
+        subscriptions: [
+          {
+            name: 'Netflix',
+            category: 'invalid-category',
+            price: 15.99,
+            currency: 'USD',
+            billingCycle: 'monthly',
+            nextBillingDate: '2026-05-01',
+          },
+        ],
+        mode: 'create' as ImportMode,
+      };
+
+      const result = validateImport(data);
+      expect(result.warnings.some(w => w.field === 'category')).toBe(true);
+    });
+  });
+
+  describe('Import Processing', () => {
+    it('should create new subscriptions in create mode', () => {
+      const data = {
+        subscriptions: [
+          {
+            name: 'Netflix',
+            category: 'streaming',
+            price: 15.99,
+            currency: 'USD',
+            billingCycle: 'monthly',
+            nextBillingDate: '2026-05-01',
+          },
+        ],
+        mode: 'create' as ImportMode,
+      };
+
+      const result = processImport(data, []);
+      expect(result.success).toBe(true);
+      expect(result.imported).toBe(1);
+      expect(result.updated).toBe(0);
+    });
+
+    it('should update existing subscriptions in upsert mode', () => {
+      const existing: Subscription[] = [
+        {
+          id: '1',
+          name: 'Netflix',
+          category: SubscriptionCategory.STREAMING,
+          price: 10,
+          currency: 'USD',
+          billingCycle: BillingCycle.MONTHLY,
+          nextBillingDate: new Date('2026-05-01'),
+          isActive: true,
+          notificationsEnabled: true,
+          isCryptoEnabled: false,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      const data = {
+        subscriptions: [
+          {
+            name: 'Netflix',
+            category: 'streaming',
+            price: 15.99,
+            currency: 'USD',
+            billingCycle: 'monthly',
+            nextBillingDate: '2026-05-01',
+          },
+        ],
+        mode: 'upsert' as ImportMode,
+      };
+
+      const result = processImport(data, existing);
+      expect(result.success).toBe(true);
+      expect(result.imported).toBe(0);
+      expect(result.updated).toBe(1);
+    });
+
+    it('should handle duplicate detection', () => {
+      const existing: Subscription[] = [
+        {
+          id: '1',
+          name: 'Netflix',
+          category: SubscriptionCategory.STREAMING,
+          price: 10,
+          currency: 'USD',
+          billingCycle: BillingCycle.MONTHLY,
+          nextBillingDate: new Date('2026-05-01'),
+          isActive: true,
+          notificationsEnabled: true,
+          isCryptoEnabled: false,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ];
+
+      const data = {
+        subscriptions: [
+          {
+            name: 'Netflix',
+            category: 'streaming',
+            price: 15.99,
+            currency: 'USD',
+            billingCycle: 'monthly',
+            nextBillingDate: '2026-05-01',
+          },
+        ],
+        mode: 'create' as ImportMode,
+      };
+
+      const result = processImport(data, existing);
+      expect(result.imported).toBe(0);
+      expect(result.failed).toBe(1);
+    });
+  });
+
+  describe('Format Detection', () => {
+    it('should detect JSON format', () => {
+      expect(detectFormat('[{"name": "test"}]')).toBe('json');
+      expect(detectFormat('{"name": "test"}')).toBe('json');
+    });
+
+    it('should detect CSV format', () => {
+      expect(detectFormat('name,description,price\nTest,Test desc,10')).toBe('csv');
+    });
+
+    it('should return unknown for invalid format', () => {
+      expect(detectFormat('invalid data')).toBe('unknown');
+    });
+  });
+
+  describe('Templates', () => {
+    it('should generate valid CSV template', () => {
+      const template = getCSVTemplate();
+      const result = parseCSV(template);
+      expect(result.length).toBeGreaterThan(0);
+      expect(result[0].name).toBe('Netflix');
+    });
+
+    it('should generate valid JSON template', () => {
+      const template = getJSONTemplate();
+      const result = parseJSON(template);
+      expect(result.length).toBeGreaterThan(0);
+      expect(result[0].name).toBe('Netflix');
+    });
+  });
+});
\ No newline at end of file
diff --git a/src/utils/importExport.ts b/src/utils/importExport.ts
new file mode 100644
index 0000000..dac8d62
--- /dev/null
+++ b/src/utils/importExport.ts
@@ -0,0 +1,761 @@
+/**
+ * Import/Export Utilities for Subscriptions
+ * Supports CSV import with column mapping and JSON export
+ */
+
+import { Subscription, SubscriptionCategory, BillingCycle } from '../types/subscription';
+
+// ============================================
+// Types
+// ============================================
+
+export interface ImportData {
+  subscriptions: SubscriptionInput[];
+  mode: ImportMode;
+}
+
+export interface SubscriptionInput {
+  id?: string;
+  name: string;
+  description?: string;
+  category: string;
+  price: number;
+  currency: string;
+  billingCycle: string;
+  nextBillingDate: string;
+  isActive?: boolean;
+  notificationsEnabled?: boolean;
+  isCryptoEnabled?: boolean;
+  cryptoToken?: string;
+  cryptoAmount?: number;
+}
+
+export type ImportMode = 'create' | 'upsert' | 'replace';
+
+export interface ImportResult {
+  success: boolean;
+  imported: number;
+  updated: number;
+  failed: number;
+  errors: ImportError[];
+  warnings: ImportWarning[];
+}
+
+export interface ImportError {
+  row: number;
+  field: string;
+  message: string;
+  value?: string;
+}
+
+export interface ImportWarning {
+  row: number;
+  field: string;
+  message: string;
+  value?: string;
+}
+
+export interface ValidationResult {
+  isValid: boolean;
+  errors: ImportError[];
+  warnings: ImportWarning[];
+  validRows: SubscriptionInput[];
+}
+
+export interface ExportData {
+  version: string;
+  exportedAt: string;
+  subscriptionCount: number;
+  subscriptions: Subscription[];
+}
+
+export interface ColumnMapping {
+  csvColumn: string;
+  fieldName: keyof SubscriptionInput;
+  required: boolean;
+  transform?: (value: string) => unknown;
+}
+
+export interface ImportHistoryEntry {
+  id: string;
+  timestamp: string;
+  fileName: string;
+  mode: ImportMode;
+  totalRows: number;
+  imported: number;
+  updated: number;
+  failed: number;
+  status: 'success' | 'partial' | 'failed';
+}
+
+// ============================================
+// Constants
+// ============================================
+
+export const CSV_COLUMN_MAPPING: ColumnMapping[] = [
+  { csvColumn: 'name', fieldName: 'name', required: true },
+  { csvColumn: 'description', fieldName: 'description', required: false },
+  { csvColumn: 'category', fieldName: 'category', required: true },
+  { csvColumn: 'price', fieldName: 'price', required: true, transform: parseFloat },
+  { csvColumn: 'currency', fieldName: 'currency', required: false },
+  { csvColumn: 'billingCycle', fieldName: 'billingCycle', required: true },
+  { csvColumn: 'nextBillingDate', fieldName: 'nextBillingDate', required: true },
+  { csvColumn: 'isActive', fieldName: 'isActive', required: false, transform: parseBoolean },
+  { csvColumn: 'notificationsEnabled', fieldName: 'notificationsEnabled', required: false, transform: parseBoolean },
+  { csvColumn: 'isCryptoEnabled', fieldName: 'isCryptoEnabled', required: false, transform: parseBoolean },
+  { csvColumn: 'cryptoToken', fieldName: 'cryptoToken', required: false },
+  { csvColumn: 'cryptoAmount', fieldName: 'cryptoAmount', required: false, transform: parseFloat },
+];
+
+export const VALID_CATEGORIES = Object.values(SubscriptionCategory);
+export const VALID_BILLING_CYCLES = Object.values(BillingCycle);
+export const VALID_CURRENCIES = ['USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 'CHF', 'XLM'];
+
+const EXPORT_VERSION = '1.0.0';
+const HISTORY_KEY = 'subtrackr-import-history';
+const MAX_HISTORY_ENTRIES = 50;
+
+// ============================================
+// Helper Functions
+// ============================================
+
+function parseBoolean(value: string): boolean {
+  const lower = value.toLowerCase().trim();
+  return lower === 'true' || lower === '1' || lower === 'yes';
+}
+
+function generateUniqueId(): string {
+  const timestamp = Date.now().toString(36);
+  const randomComponent = Math.random().toString(36).substring(2, 8);
+  return `${timestamp}-${randomComponent}`;
+}
+
+function generateHistoryId(): string {
+  return `import-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+}
+
+function normalizeCategory(value: string): SubscriptionCategory {
+  const normalized = value.toLowerCase().trim() as SubscriptionCategory;
+  if (VALID_CATEGORIES.includes(normalized)) {
+    return normalized;
+  }
+  // Try to match by partial string
+  for (const cat of VALID_CATEGORIES) {
+    if (cat.includes(normalized) || normalized.includes(cat)) {
+      return cat;
+    }
+  }
+  return SubscriptionCategory.OTHER;
+}
+
+function normalizeBillingCycle(value: string): BillingCycle {
+  const normalized = value.toLowerCase().trim() as BillingCycle;
+  if (VALID_BILLING_CYCLES.includes(normalized)) {
+    return normalized;
+  }
+  // Try common variations
+  const cycleMap: Record<string, BillingCycle> = {
+    'month': BillingCycle.MONTHLY,
+    'year': BillingCycle.YEARLY,
+    'week': BillingCycle.WEEKLY,
+    'custom': BillingCycle.CUSTOM,
+  };
+  for (const [key, cycle] of Object.entries(cycleMap)) {
+    if (normalized.includes(key)) {
+      return cycle;
+    }
+  }
+  return BillingCycle.MONTHLY;
+}
+
+function parseDate(value: string): Date {
+  const parsed = new Date(value);
+  if (!Number.isNaN(parsed.getTime())) {
+    return parsed;
+  }
+  // Try common formats
+  const formats = [
+    /^(\d{4})-(\d{2})-(\d{2})$/, // YYYY-MM-DD
+    /^(\d{2})\/(\d{2})\/(\d{4})$/, // MM/DD/YYYY
+    /^(\d{2})-(\d{2})-(\d{4})$/, // DD-MM-YYYY
+  ];
+  
+  for (const format of formats) {
+    const match = value.match(format);
+    if (match) {
+      const date = new Date(value);
+      if (!Number.isNaN(date.getTime())) {
+        return date;
+      }
+    }
+  }
+  
+  return new Date(); // Default to current date
+}
+
+// ============================================
+// CSV Parsing
+// ============================================
+
+/**
+ * Parse CSV string into array of subscription objects
+ */
+export function parseCSV(csvContent: string): SubscriptionInput[] {
+  const lines = csvContent.split(/\r?\n/).filter(line => line.trim());
+  
+  if (lines.length < 2) {
+    throw new Error('CSV must contain at least a header row and one data row');
+  }
+
+  const headerLine = lines[0];
+  const headers = parseCSVLine(headerLine);
+  
+  // Create header to field mapping
+  const headerMap = new Map<string, number>();
+  headers.forEach((header, index) => {
+    headerMap.set(header.toLowerCase().trim(), index);
+  });
+
+  const subscriptions: SubscriptionInput[] = [];
+
+  for (let i = 1; i < lines.length; i++) {
+    const values = parseCSVLine(lines[i]);
+    if (values.length === 0 || values.every(v => !v.trim())) {
+      continue; // Skip empty rows
+    }
+
+    const subscription: Partial<SubscriptionInput> = {};
+    
+    for (const mapping of CSV_COLUMN_MAPPING) {
+      const columnIndex = headerMap.get(mapping.csvColumn.toLowerCase());
+      if (columnIndex !== undefined && values[columnIndex]) {
+        const rawValue = values[columnIndex];
+        const value = mapping.transform ? 
+          String(mapping.transform(rawValue)) : 
+          rawValue;
+        
+        (subscription as Record<string, unknown>)[mapping.fieldName] = value;
+      }
+    }
+
+    if (subscription.name) {
+      subscriptions.push(subscription as SubscriptionInput);
+    }
+  }
+
+  return subscriptions;
+}
+
+function parseCSVLine(line: string): string[] {
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    
+    if (char === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (char === ',' && !inQuotes) {
+      result.push(current.trim());
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+
+  result.push(current.trim());
+  return result;
+}
+
+/**
+ * Generate CSV from subscriptions
+ */
+export function generateCSV(subscriptions: Subscription[]): string {
+  const headers = CSV_COLUMN_MAPPING.map(m => m.csvColumn);
+  const rows = subscriptions.map(sub => {
+    return CSV_COLUMN_MAPPING.map(mapping => {
+      const value = sub[mapping.fieldName as keyof Subscription];
+      if (value === undefined || value === null) {
+        return '';
+      }
+      if (typeof value === 'string' && (value.includes(',') || value.includes('"'))) {
+        return `"${value.replace(/"/g, '""')}"`;
+      }
+      if (value instanceof Date) {
+        return value.toISOString().split('T')[0];
+      }
+      return String(value);
+    }).join(',');
+  });
+
+  return [headers.join(','), ...rows].join('\n');
+}
+
+// ============================================
+// JSON Export
+// ============================================
+
+/**
+ * Export subscriptions to JSON format
+ */
+export function exportToJSON(subscriptions: Subscription[]): string {
+  const exportData: ExportData = {
+    version: EXPORT_VERSION,
+    exportedAt: new Date().toISOString(),
+    subscriptionCount: subscriptions.length,
+    subscriptions: subscriptions.map(sub => ({
+      ...sub,
+      nextBillingDate: sub.nextBillingDate instanceof Date ? 
+        sub.nextBillingDate : 
+        new Date(sub.nextBillingDate as unknown as string),
+      createdAt: sub.createdAt instanceof Date ? 
+        sub.createdAt : 
+        new Date(sub.createdAt as unknown as string),
+      updatedAt: sub.updatedAt instanceof Date ? 
+        sub.updatedAt : 
+        new Date(sub.updatedAt as unknown as string),
+    })),
+  };
+
+  return JSON.stringify(exportData, null, 2);
+}
+
+/**
+ * Parse JSON import data
+ */
+export function parseJSON(jsonContent: string): SubscriptionInput[] {
+  const data = JSON.parse(jsonContent);
+  
+  // Handle both direct array and wrapped export format
+  let subscriptions: Subscription[] | SubscriptionInput[];
+  
+  if (Array.isArray(data)) {
+    subscriptions = data;
+  } else if (data.subscriptions && Array.isArray(data.subscriptions)) {
+    subscriptions = data.subscriptions;
+  } else {
+    throw new Error('Invalid JSON format: expected array or export object');
+  }
+
+  return subscriptions.map(sub => ({
+    id: sub.id,
+    name: sub.name,
+    description: sub.description,
+    category: typeof sub.category === 'string' ? sub.category : SubscriptionCategory.OTHER,
+    price: Number(sub.price) || 0,
+    currency: sub.currency || 'USD',
+    billingCycle: typeof sub.billingCycle === 'string' ? sub.billingCycle : BillingCycle.MONTHLY,
+    nextBillingDate: sub.nextBillingDate ? new Date(sub.nextBillingDate).toISOString() : new Date().toISOString(),
+    isActive: sub.isActive,
+    notificationsEnabled: sub.notificationsEnabled,
+    isCryptoEnabled: sub.isCryptoEnabled,
+    cryptoToken: sub.cryptoToken,
+    cryptoAmount: sub.cryptoAmount,
+  }));
+}
+
+// ============================================
+// Validation
+// ============================================
+
+/**
+ * Validate import data
+ */
+export function validateImport(data: ImportData): ValidationResult {
+  const errors: ImportError[] = [];
+  const warnings: ImportWarning[] = [];
+  const validRows: SubscriptionInput[] = [];
+
+  data.subscriptions.forEach((subscription, index) => {
+    const rowNum = index + 1;
+
+    // Required field validation
+    if (!subscription.name || subscription.name.trim() === '') {
+      errors.push({
+        row: rowNum,
+        field: 'name',
+        message: 'Name is required',
+        value: subscription.name,
+      });
+      return;
+    }
+
+    // Category validation
+    if (!subscription.category) {
+      errors.push({
+        row: rowNum,
+        field: 'category',
+        message: 'Category is required',
+        value: subscription.category,
+      });
+    } else if (!VALID_CATEGORIES.includes(subscription.category.toLowerCase() as SubscriptionCategory)) {
+      warnings.push({
+        row: rowNum,
+        field: 'category',
+        message: `Invalid category "${subscription.category}", defaulting to "other"`,
+        value: subscription.category,
+      });
+    }
+
+    // Price validation
+    if (subscription.price === undefined || subscription.price === null) {
+      errors.push({
+        row: rowNum,
+        field: 'price',
+        message: 'Price is required',
+        value: String(subscription.price),
+      });
+      return;
+    }
+
+    if (isNaN(subscription.price) || subscription.price < 0) {
+      errors.push({
+        row: rowNum,
+        field: 'price',
+        message: 'Price must be a valid positive number',
+        value: String(subscription.price),
+      });
+      return;
+    }
+
+    // Billing cycle validation
+    if (!subscription.billingCycle) {
+      errors.push({
+        row: rowNum,
+        field: 'billingCycle',
+        message: 'Billing cycle is required',
+        value: subscription.billingCycle,
+      });
+    } else if (!VALID_BILLING_CYCLES.includes(subscription.billingCycle.toLowerCase() as BillingCycle)) {
+      warnings.push({
+        row: rowNum,
+        field: 'billingCycle',
+        message: `Invalid billing cycle "${subscription.billingCycle}", defaulting to "monthly"`,
+        value: subscription.billingCycle,
+      });
+    }
+
+    // Currency validation
+    if (subscription.currency && !VALID_CURRENCIES.includes(subscription.currency.toUpperCase())) {
+      warnings.push({
+        row: rowNum,
+        field: 'currency',
+        message: `Non-standard currency "${subscription.currency}"`,
+        value: subscription.currency,
+      });
+    }
+
+    // Date validation
+    if (subscription.nextBillingDate) {
+      const date = new Date(subscription.nextBillingDate);
+      if (Number.isNaN(date.getTime())) {
+        errors.push({
+          row: rowNum,
+          field: 'nextBillingDate',
+          message: 'Invalid date format',
+          value: subscription.nextBillingDate,
+        });
+        return;
+      }
+    }
+
+    // Crypto validation
+    if (subscription.isCryptoEnabled && !subscription.cryptoToken) {
+      warnings.push({
+        row: rowNum,
+        field: 'cryptoToken',
+        message: 'Crypto enabled but no token specified',
+        value: subscription.cryptoToken,
+      });
+    }
+
+    validRows.push(subscription);
+  });
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings,
+    validRows,
+  };
+}
+
+// ============================================
+// Import Processing
+// ============================================
+
+/**
+ * Process import with validation
+ */
+export function processImport(
+  data: ImportData,
+  existingSubscriptions: Subscription[]
+): ImportResult {
+  const validation = validateImport(data);
+  
+  if (validation.validRows.length === 0 && validation.errors.length > 0) {
+    return {
+      success: false,
+      imported: 0,
+      updated: 0,
+      failed: data.subscriptions.length,
+      errors: validation.errors,
+      warnings: validation.warnings,
+    };
+  }
+
+  let imported = 0;
+  let updated = 0;
+  const errors: ImportError[] = [...validation.errors];
+  const warnings: ImportWarning[] = [...validation.warnings];
+
+  // Create lookup for existing subscriptions
+  const existingByName = new Map<string, Subscription>();
+  const existingById = new Map<string, Subscription>();
+  
+  existingSubscriptions.forEach(sub => {
+    existingByName.set(sub.name.toLowerCase(), sub);
+    if (sub.id) {
+      existingById.set(sub.id, sub);
+    }
+  });
+
+  const processedSubscriptions: Subscription[] = [];
+
+  validation.validRows.forEach((input, index) => {
+    const rowNum = index + 1;
+    const now = new Date();
+
+    try {
+      // Check for duplicates
+      const existingByNameMatch = existingByName.get(input.name.toLowerCase());
+      const existingByIdMatch = input.id ? existingById.get(input.id) : null;
+      const isUpdate = (existingByNameMatch || existingByIdMatch) && data.mode === 'upsert';
+      const isReplace = data.mode === 'replace';
+
+      if (isUpdate || isReplace) {
+        // Update existing
+        const existing = existingByIdMatch || existingByNameMatch;
+        if (existing) {
+          const updated: Subscription = {
+            ...existing,
+            name: input.name,
+            description: input.description,
+            category: normalizeCategory(input.category),
+            price: input.price,
+            currency: input.currency?.toUpperCase() || 'USD',
+            billingCycle: normalizeBillingCycle(input.billingCycle),
+            nextBillingDate: parseDate(input.nextBillingDate),
+            isActive: input.isActive ?? existing.isActive,
+            notificationsEnabled: input.notificationsEnabled ?? existing.notificationsEnabled,
+            isCryptoEnabled: input.isCryptoEnabled ?? existing.isCryptoEnabled,
+            cryptoToken: input.cryptoToken ?? existing.cryptoToken,
+            cryptoAmount: input.cryptoAmount ?? existing.cryptoAmount,
+            updatedAt: now,
+          };
+          processedSubscriptions.push(updated);
+          updated++;
+        }
+      } else {
+        // Create new
+        const newSubscription: Subscription = {
+          id: input.id || generateUniqueId(),
+          name: input.name,
+          description: input.description,
+          category: normalizeCategory(input.category),
+          price: input.price,
+          currency: input.currency?.toUpperCase() || 'USD',
+          billingCycle: normalizeBillingCycle(input.billingCycle),
+          nextBillingDate: parseDate(input.nextBillingDate),
+          isActive: input.isActive ?? true,
+          notificationsEnabled: input.notificationsEnabled ?? true,
+          isCryptoEnabled: input.isCryptoEnabled ?? false,
+          cryptoToken: input.cryptoToken,
+          cryptoAmount: input.cryptoAmount,
+          createdAt: now,
+          updatedAt: now,
+        };
+        processedSubscriptions.push(newSubscription);
+        imported++;
+      }
+    } catch (err) {
+      errors.push({
+        row: rowNum,
+        field: 'general',
+        message: err instanceof Error ? err.message : 'Unknown error',
+      });
+    }
+  });
+
+  return {
+    success: errors.length === 0,
+    imported,
+    updated,
+    failed: data.subscriptions.length - imported - updated,
+    errors,
+    warnings,
+  };
+}
+
+// ============================================
+// Import History
+// ============================================
+
+/**
+ * Get import history from storage
+ */
+export async function getImportHistory(): Promise<ImportHistoryEntry[]> {
+  try {
+    const AsyncStorage = require('@react-native-async-storage/async-storage').default;
+    const historyJson = await AsyncStorage.getItem(HISTORY_KEY);
+    if (historyJson) {
+      return JSON.parse(historyJson);
+    }
+  } catch (error) {
+    console.error('Failed to get import history:', error);
+  }
+  return [];
+}
+
+/**
+ * Save import history entry
+ */
+export async function saveImportHistory(entry: ImportHistoryEntry): Promise<void> {
+  try {
+    const AsyncStorage = require('@react-native-async-storage/async-storage').default;
+    const history = await getImportHistory();
+    
+    history.unshift(entry);
+    
+    // Keep only last N entries
+    const trimmedHistory = history.slice(0, MAX_HISTORY_ENTRIES);
+    
+    await AsyncStorage.setItem(HISTORY_KEY, JSON.stringify(trimmedHistory));
+  } catch (error) {
+    console.error('Failed to save import history:', error);
+  }
+}
+
+/**
+ * Create and save import history entry
+ */
+export async function recordImport(
+  fileName: string,
+  mode: ImportMode,
+  totalRows: number,
+  result: ImportResult
+): Promise<void> {
+  const entry: ImportHistoryEntry = {
+    id: generateHistoryId(),
+    timestamp: new Date().toISOString(),
+    fileName,
+    mode,
+    totalRows,
+    imported: result.imported,
+    updated: result.updated,
+    failed: result.failed,
+    status: result.success ? 'success' : result.failed === totalRows ? 'failed' : 'partial',
+  };
+
+  await saveImportHistory(entry);
+}
+
+/**
+ * Clear import history
+ */
+export async function clearImportHistory(): Promise<void> {
+  try {
+    const AsyncStorage = require('@react-native-async-storage/async-storage').default;
+    await AsyncStorage.removeItem(HISTORY_KEY);
+  } catch (error) {
+    console.error('Failed to clear import history:', error);
+  }
+}
+
+// ============================================
+// Utility Functions
+// ============================================
+
+/**
+ * Detect file format from content
+ */
+export function detectFormat(content: string): 'csv' | 'json' | 'unknown' {
+  const trimmed = content.trim();
+  
+  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+    try {
+      JSON.parse(trimmed);
+      return 'json';
+    } catch {
+      // Not valid JSON
+    }
+  }
+  
+  // Check for CSV indicators
+  if (trimmed.includes(',') && trimmed.split('\n')[0].split(',').length > 1) {
+    return 'csv';
+  }
+  
+  return 'unknown';
+}
+
+/**
+ * Get sample CSV template
+ */
+export function getCSVTemplate(): string {
+  return `name,description,category,price,currency,billingCycle,nextBillingDate,isActive,notificationsEnabled,isCryptoEnabled,cryptoToken,cryptoAmount
+Netflix,Streaming service,streaming,15.99,USD,monthly,2026-05-01,true,true,false,,
+Spotify,Music streaming,streaming,9.99,USD,monthly,2026-05-15,true,true,false,,
+Adobe Creative Cloud,Design software,software,54.99,USD,monthly,2026-05-20,true,true,true,XLM,0.5`;
+}
+
+/**
+ * Get sample JSON template
+ */
+export function getJSONTemplate(): string {
+  const template: ExportData = {
+    version: EXPORT_VERSION,
+    exportedAt: new Date().toISOString(),
+    subscriptionCount: 2,
+    subscriptions: [
+      {
+        id: 'sample-1',
+        name: 'Netflix',
+        description: 'Streaming service',
+        category: SubscriptionCategory.STREAMING,
+        price: 15.99,
+        currency: 'USD',
+        billingCycle: BillingCycle.MONTHLY,
+        nextBillingDate: new Date('2026-05-01'),
+        isActive: true,
+        notificationsEnabled: true,
+        isCryptoEnabled: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+      {
+        id: 'sample-2',
+        name: 'Spotify',
+        description: 'Music streaming',
+        category: SubscriptionCategory.STREAMING,
+        price: 9.99,
+        currency: 'USD',
+        billingCycle: BillingCycle.MONTHLY,
+        nextBillingDate: new Date('2026-05-15'),
+        isActive: true,
+        notificationsEnabled: true,
+        isCryptoEnabled: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+    ],
+  };
+  
+  return JSON.stringify(template, null, 2);
+}
\ No newline at end of file