stedi-rs

https://github.com/sunnyhealthai/stedi-rs
Admin
A community-maintained Rust SDK for interacting with Stedi's Healthcare Eligibility API.
Tokens:6,749
Snippets:21
Trust Score:3.4
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### Configure Stedi API Client in Rust

Source: https://context7.com/sunnyhealthai/stedi-rs/llms.txt

Demonstrates how to create an API client configuration for the stedi-rs SDK. This involves setting up authentication credentials and optional HTTP client settings, with examples for quick setup, manual configuration, and using environment variables.

```rust
use stedi_rs::apis::configuration::Configuration;

// Recommended: Use the helper method for quick setup
let config = Configuration::with_api_key("your-stedi-api-key");

// Manual configuration with custom settings
let mut config = Configuration::default();
config.bearer_access_token = Some(format!("Key {}", "your-api-key"));
config.base_path = "https://healthcare.us.stedi.com".to_string();

// Using environment variable (production pattern)
let api_key = std::env::var("STEDI_API_KEY").expect("STEDI_API_KEY must be set");
let config = Configuration::with_api_key(api_key);
```

--------------------------------

### Cargo.toml Dependencies for stedi-rs

Source: https://github.com/sunnyhealthai/stedi-rs/blob/main/README.md

This snippet shows the necessary dependencies in Cargo.toml to use the stedi-rs crate along with tokio for asynchronous operations. Ensure you have compatible versions installed.

```toml
[dependencies]
stedi-rs = "0.0.1"
tokio = { version = "1.48", features = ["full"] }
```

--------------------------------

### Calculate Patient Costs with Benefits Calculator (Rust)

Source: https://context7.com/sunnyhealthai/stedi-rs/llms.txt

Demonstrates how to use the stedi-rs benefits calculator to parse eligibility response data and calculate patient out-of-pocket costs. It includes parsing benefits, getting a summary, calculating costs for a procedure, and estimating costs with prior year-to-date accumulations. This function requires the `stedi_rs::models::EligibilityCheckResponseContent` and various types from `stedi_rs::utilities::benefits_calculator`.

```rust
// Enable in Cargo.toml:
// [dependencies]
// stedi-rs = { version = "0.0.1", features = ["benefits-calculator"] }

use stedi_rs::utilities::benefits_calculator::{
    parse_benefits, calculate_out_of_pocket, calculate_with_accumulations,
    get_benefits_summary,
    NetworkStatus, ProviderInfo, ProcedureDetails,
    AccumulatedAmounts, ParsedBenefit, BenefitType,
};
use stedi_rs::models::EligibilityCheckResponseContent;

// Parse raw benefits from eligibility response
fn calculate_patient_costs(response: &EligibilityCheckResponseContent) {
    let raw_benefits = response.benefits_information.as_ref().unwrap();
    let parsed_benefits: Vec<ParsedBenefit> = parse_benefits(raw_benefits);

    // Get summary of key benefits
    let summary = get_benefits_summary(&parsed_benefits);
    for (key, value) in &summary {
        println!("{}: {}", key, value);
    }
    // Output example:
    // "InNetwork Individual Deductible: $1500.00 (approx. $1200.00 remaining)"
    // "InNetwork Individual OOP Maximum: $5000.00 (approx. $3800.00 remaining)"

    // Define procedure details
    let office_visit = ProcedureDetails {
        code: "99213".to_string(),
        name: "Office Visit - Established Patient".to_string(),
        cost: 150.00,
        service_type_codes: vec!["98".to_string()],  // Professional (Physician) Visit - Office
    };

    let provider = ProviderInfo {
        is_specialist: false,
    };

    // Calculate costs without prior accumulations
    let result = calculate_out_of_pocket(
        &parsed_benefits,
        &office_visit,
        NetworkStatus::InNetwork,
        &provider,
    );

    println!("Patient Pays: ${:.2}", result.patient_pays);
    println!("Insurance Pays: ${:.2}", result.insurance_pays);
    println!("Copay Applied: ${:.2}", result.calculation_details.copay_applied);
    println!("Deductible Applied: ${:.2}", result.calculation_details.deductible_applied);
    println!("Explanation: {}", result.calculation_details.explanation);

    // Calculate with prior year-to-date accumulations
    let accumulated = AccumulatedAmounts {
        individual_deductible_met: 500.00,
        family_deductible_met: 750.00,
        individual_oop_met: 1200.00,
        family_oop_met: 1800.00,
    };

    let surgery = ProcedureDetails {
        code: "63030".to_string(),
        name: "Spinal Surgery".to_string(),
        cost: 15000.00,
        service_type_codes: vec!["48".to_string()],  // Hospital - Inpatient
    };

    let surgery_result = calculate_with_accumulations(
        &parsed_benefits,
        &surgery,
        NetworkStatus::InNetwork,
        &ProviderInfo { is_specialist: true },
        &accumulated,
    );

    println!("\nSurgery Cost Estimate:");
    println!("  Provider Charge: ${:.2}", surgery_result.calculation_details.provider_charge);
    println!("  Deductible Applied: ${:.2}", surgery_result.calculation_details.deductible_applied);
    println!("  Coinsurance Applied: ${:.2}", surgery_result.calculation_details.coinsurance_applied);
    println!("  Patient Pays: ${:.2}", surgery_result.patient_pays);
    println!("  Insurance Pays: ${:.2}", surgery_result.insurance_pays);
    println!("  OOP Max Limited: {}", surgery_result.calculation_details.oop_max_limited);
    println!("  Remaining Deductible: ${:.2}", surgery_result.calculation_details.remaining_deductible);
    println!("  Remaining OOP Max: ${:.2}", surgery_result.calculation_details.remaining_oop_max);

    // Warnings about data quality
    for warning in &surgery_result.warnings {
        println!("Warning: {}", warning);
    }
}

```

--------------------------------

### Configure Provider Information (Rust)

Source: https://context7.com/sunnyhealthai/stedi-rs/llms.txt

Defines the `Provider` struct for healthcare provider details in eligibility requests. Requires either `organization_name` or `first_name`/`last_name`, along with a primary identifier like NPI. Examples cover individual practitioners, organizations, and providers with addresses.

```rust
use stedi_rs::models::{Provider, ProviderType, RequestAddress};

// Individual practitioner
let individual_provider = Provider {
    first_name: Some("Jane".to_string()),
    last_name: Some("Smith".to_string()),
    npi: Some("1234567890".to_string()),
    provider_type: Some(ProviderType::Provider),
    ..Default::default()
};

// Healthcare organization
let organization_provider = Provider {
    organization_name: Some("City General Hospital".to_string()),
    npi: Some("1234567890".to_string()),
    provider_type: Some(ProviderType::Hospital),
    tax_id: Some("12-3456789".to_string()),  // Only if required by payer
    ..Default::default()
};

// Provider with multiple locations (include address when needed)
let provider_with_location = Provider {
    organization_name: Some("Multi-Site Medical Group".to_string()),
    npi: Some("1234567890".to_string()),
    provider_type: Some(ProviderType::Facility),
    address: Some(RequestAddress {
        address1: Some("456 Healthcare Blvd".to_string()),
        city: Some("Los Angeles".to_string()),
        state: Some("CA".to_string()),
        postal_code: Some("90001".to_string()),
        ..Default::default()
    }),
    ..Default::default()
};
```

--------------------------------

### Define Subscriber Information (Rust)

Source: https://context7.com/sunnyhealthai/stedi-rs/llms.txt

Defines the `RequestSubscriber` struct for storing primary policyholder information. It requires at least one of member ID, date of birth, or last name, but recommends including all four key fields for optimal results. Examples show basic, Medicaid, and address-inclusive configurations.

```rust
use stedi_rs::models::{RequestSubscriber, Gender, RequestAddress};

// Basic subscriber with required fields
let mut subscriber = RequestSubscriber::new();
subscriber.member_id = Some("MEMBER123456".to_string());
subscriber.first_name = Some("John".to_string());
subscriber.last_name = Some("Doe".to_string());
subscriber.date_of_birth = Some("19800115".to_string());  // YYYYMMDD format
subscriber.group_number = Some("GROUP001".to_string());
subscriber.gender = Some(Gender::Male);

// Medicaid subscriber with ID card (when different from member ID)
let mut medicaid_subscriber = RequestSubscriber::new();
medicaid_subscriber.member_id = Some("MEMBER789".to_string());
medicaid_subscriber.id_card = Some("IDCARD456".to_string());
medicaid_subscriber.first_name = Some("Jane".to_string());
medicaid_subscriber.last_name = Some("Smith".to_string());
medicaid_subscriber.date_of_birth = Some("19750320".to_string());
medicaid_subscriber.medicaid_recipient_identification_number = Some("MCD12345".to_string());

// Subscriber with address (when required by payer)
let mut subscriber_with_address = RequestSubscriber::new();
subscriber_with_address.member_id = Some("MBR999".to_string());
subscriber_with_address.first_name = Some("Alice".to_string());
subscriber_with_address.last_name = Some("Johnson".to_string());
subscriber_with_address.date_of_birth = Some("19900501".to_string());
subscriber_with_address.address = Some(RequestAddress {
    address1: Some("123 Main Street".to_string()),
    city: Some("San Francisco".to_string()),
    state: Some("CA".to_string()),
    postal_code: Some("94102".to_string()),
    ..Default::default()
});
```

--------------------------------

### Perform Real-time Eligibility Check in Rust

Source: https://context7.com/sunnyhealthai/stedi-rs/llms.txt

Demonstrates how to perform a synchronous healthcare eligibility check using the `stedi_rs` crate. It requires provider and subscriber details, and returns benefits information. Dependencies include `stedi_rs` and `tokio`.

```rust
use stedi_rs::apis::{configuration::Configuration, eligibility_check};
use stedi_rs::models::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = Configuration::with_api_key(std::env::var("STEDI_API_KEY")?);

    // Build eligibility check request
    let request = EligibilityCheckRequestContent {
        control_number: "123456789".to_string(),  // Transaction identifier
        trading_partner_service_id: "87726".to_string(),  // Payer ID (e.g., UnitedHealthcare)
        provider: Provider {
            organization_name: Some("ACME Health Services".to_string()),
            npi: Some("1234567890".to_string()),  // National Provider Identifier
            ..Default::default()
        },
        subscriber: RequestSubscriber {
            member_id: Some("UHC123456".to_string()),
            first_name: Some("Jane".to_string()),
            last_name: Some("Doe".to_string()),
            date_of_birth: Some("19800101".to_string()),  // YYYYMMDD format
            ..Default::default()
        },
        encounter: Some(Encounter {
            service_type_codes: Some(vec![
                RequestEligibilityServiceTypeCode::HealthBenefitPlanCoverage,  // General benefits
            ]),
            ..Default::default()
        }),
        ..Default::default()
    };

    // Execute eligibility check
    let response = eligibility_check::eligibility_check(&config, request).await?;

    // Check plan status
    if let Some(plan_status) = &response.plan_status {
        println!("Plan Status: {:?}", plan_status);
    }

    // Access subscriber information
    if let Some(subscriber) = &response.subscriber {
        println!("Subscriber: {} {}",
            subscriber.first_name.as_deref().unwrap_or(""),
            subscriber.last_name.as_deref().unwrap_or(""));
        println!("Group Number: {:?}", subscriber.group_number);
    }

    // Process benefits information
    if let Some(benefits) = &response.benefits_information {
        println!("Found {} benefit entries", benefits.len());

        for benefit in benefits {
            if let Some(name) = &benefit.name {
                println!("Benefit: {:?}", name);
            }
            if let Some(amount) = &benefit.benefit_amount {
                println!("  Amount: ${}", amount);
            }
            if let Some(percent) = &benefit.benefit_percent {
                println!("  Percent: {}%", (percent.parse::<f64>().unwrap_or(0.0) * 100.0));
            }
        }
    }

    // Check for errors
    if let Some(errors) = &response.errors {
        for error in errors {
            eprintln!("Error: {:?}", error);
        }
    }

    Ok(())
}

```

--------------------------------

### Process Benefits Information in Rust

Source: https://context7.com/sunnyhealthai/stedi-rs/llms.txt

Processes a list of benefits information from an eligibility response. It identifies active coverage, extracts deductible details (coverage level, network, time qualifier, amount), copay information (service types, amount), coinsurance rates (network, percentage), and out-of-pocket maximums (level, amount).

```rust
use stedi_rs::models::{
    EligibilityCheckResponseContent,
    BenefitsInformation,
    BenefitsInformationCode,
    BenefitsInformationCoverageLevelCode,
    InPlanNetworkIndicatorCode,
};

fn process_benefits(response: &EligibilityCheckResponseContent) {
    let benefits = response.benefits_information.as_ref().unwrap_or(&vec![]);

    // Find active coverage status
    let has_active_coverage = benefits.iter().any(|b| {
        matches!(b.code, Some(BenefitsInformationCode::ActiveCoverage))
    });
    println!("Active Coverage: {}", has_active_coverage);

    // Extract deductible information
    for benefit in benefits.iter() {
        if matches!(benefit.code, Some(BenefitsInformationCode::Deductible)) {
            let coverage_level = benefit.coverage_level_code.as_ref()
                .map(|c| format!("{:?}", c))
                .unwrap_or_else(|| "Unknown".to_string());

            let network = benefit.in_plan_network_indicator_code.as_ref()
                .map(|n| match n {
                    InPlanNetworkIndicatorCode::Yes => "In-Network",
                    InPlanNetworkIndicatorCode::No => "Out-of-Network",
                    _ => "N/A",
                })
                .unwrap_or("Unknown");

            let time_qualifier = benefit.time_qualifier.as_ref()
                .map(|t| format!("{:?}", t))
                .unwrap_or_else(|| "Unknown".to_string());

            if let Some(amount) = &benefit.benefit_amount {
                println!("{} {} Deductible ({}): ${}",
                    network, coverage_level, time_qualifier, amount);
            }
        }
    }

    // Extract copay information
    for benefit in benefits.iter() {
        if matches!(benefit.code, Some(BenefitsInformationCode::CoPayment)) {
            let service_types = benefit.service_types.as_ref()
                .map(|st| st.iter().map(|s| format!("{:?}", s)).collect::<Vec<_>>().join(", "))
                .unwrap_or_else(|| "General".to_string());

            if let Some(amount) = &benefit.benefit_amount {
                println!("Copay for {}: ${}", service_types, amount);
            }
        }
    }

    // Extract coinsurance rates
    for benefit in benefits.iter() {
        if matches!(benefit.code, Some(BenefitsInformationCode::CoInsurance)) {
            if let Some(percent) = &benefit.benefit_percent {
                let rate = percent.parse::<f64>().unwrap_or(0.0) * 100.0;
                let network = benefit.in_plan_network.as_ref()
                    .map(|n| format!("{:?}", n))
                    .unwrap_or_else(|| "Unknown".to_string());
                println!("{} Coinsurance: {}%", network, rate);
            }
        }
    }

    // Extract out-of-pocket maximum
    for benefit in benefits.iter() {
        if matches!(benefit.code, Some(BenefitsInformationCode::OutOfPocketStopLoss)) {
            if let Some(amount) = &benefit.benefit_amount {
                let level = match benefit.coverage_level_code {
                    Some(BenefitsInformationCoverageLevelCode::Individual) => "Individual",
                    Some(BenefitsInformationCoverageLevelCode::Family) => "Family",
                    _ => "Unknown",
                };
                println!("{} Out-of-Pocket Max: ${}", level, amount);
            }
        }
    }
}

```

--------------------------------

### Perform Healthcare Eligibility Check in Rust

Source: https://github.com/sunnyhealthai/stedi-rs/blob/main/README.md

This Rust code demonstrates how to perform a healthcare eligibility check using the stedi-rs SDK. It sets up the API configuration with an environment variable for the API key, constructs an EligibilityCheckRequestContent object, and makes an asynchronous call to the eligibility_check API endpoint. The response, if successful, prints the plan status.

```rust
use stedi_rs::apis::{configuration::Configuration, eligibility_check};
use stedi_rs::models::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("STEDI_API_KEY")?;
    let config = Configuration::with_api_key(api_key);

    let request = EligibilityCheckRequestContent {
        control_number: "123456789".to_string(),
        trading_partner_service_id: "87726".to_string(),
        provider: Provider {
            organization_name: Some("ACME Health Services".to_string()),
            npi: Some("1234567890".to_string()),
            ..Default::default()
        },
        subscriber: RequestSubscriber {
            member_id: Some("1234567890".to_string()),
            first_name: Some("Jane".to_string()),
            last_name: Some("Doe".to_string()),
            date_of_birth: Some("19800101".to_string()),
            ..Default::default()
        },
        ..Default::default()
    };

    let response = eligibility_check::eligibility_check(&config, request).await?;

    if let Some(plan_status) = &response.plan_status {
        println!("Plan Status: {:?}", plan_status);
    }

    Ok(())
}
```

--------------------------------

### Handle Eligibility Check API Errors in Rust

Source: https://context7.com/sunnyhealthai/stedi-rs/llms.txt

This Rust code snippet demonstrates how to handle potential errors when performing an eligibility check using the Stedi SDK. It covers parsing different HTTP error status codes (like 400, 403, 429, 500) and processing payer-level AAA errors within a successful response. Dependencies include the `stedi-rs` crate.

```rust
use stedi_rs::apis::{configuration::Configuration, eligibility_check, Error};
use stedi_rs::apis::eligibility_check::EligibilityCheckError;
use stedi_rs::models::*;

async fn handle_eligibility_check(config: &Configuration, request: EligibilityCheckRequestContent) {
    match eligibility_check::eligibility_check(config, request).await {
        Ok(response) => {
            // Check for payer-level AAA errors in successful response
            if let Some(errors) = &response.errors {
                if !errors.is_empty() {
                    println!("Payer returned errors:");
                    for error in errors {
                        if let Some(code) = &error.code {
                            println!("  Error Code: {:?}", code);
                        }
                        if let Some(description) = &error.description {
                            println!("  Description: {}", description);
                        }
                        // Check followup actions
                        if let Some(followup) = &error.followup_action {
                            println!("  Followup: {:?}", followup);
                        }
                    }
                    return;
                }
            }

            // Check for warnings (non-fatal issues)
            if let Some(warnings) = &response.warnings {
                for warning in warnings {
                    println!("Warning: {:?}", warning);
                }
            }

            // Process successful response
            println!("Eligibility check successful!");
            if let Some(benefits) = &response.benefits_information {
                println!("Received {} benefit entries", benefits.len());
            }
        }
        Err(Error::Response(response_content)) => {
            // Handle HTTP error responses
            println!("HTTP Status: {}", response_content.status);
            println!("Response Body: {}", response_content.content);

            if let Some(entity) = response_content.entity {
                match entity {
                    EligibilityCheckError::Status400(validation_error) => {
                        println!("Validation Error: {:?}", validation_error.message);
                        if let Some(fields) = validation_error.field_list {
                            for field in fields {
                                println!("  Field: {:?}, Message: {:?}", field.name, field.message);
                            }
                        }
                    }
                    EligibilityCheckError::Status403(access_denied) => {
                        println!("Access Denied: {:?}", access_denied.message);
                    }
                    EligibilityCheckError::Status429(throttled) => {
                        println!("Rate Limited: {:?}", throttled.message);
                        // Implement exponential backoff retry
                    }
                    EligibilityCheckError::Status500(internal_error) => {
                        println!("Internal Error: {:?}", internal_error.message);
                    }
                    EligibilityCheckError::Status503(unavailable) => {
                        println!("Service Unavailable: {:?}", unavailable.message);
                        // Retry with backoff
                    }
                    EligibilityCheckError::Status504(timeout) => {
                        println!("Gateway Timeout: {:?}", timeout.message);
                        // Payer response timeout, retry later
                    }
                    _ => {
                        println!("Unknown error response");
                    }
                }
            }
        }
        Err(Error::Reqwest(e)) => {
            println!("HTTP Request Error: {}", e);
        }
        Err(Error::Serde(e)) => {
            println!("JSON Parsing Error: {}", e);
        }
        Err(Error::Io(e)) => {
            println!("I/O Error: {}", e);
        }
    }
}

```

--------------------------------

### POST /eligibility_check

Source: https://context7.com/sunnyhealthai/stedi-rs/llms.txt

Submits a real-time 270/271 eligibility check to verify patient insurance coverage and retrieve detailed benefits information.

```APIDOC
## POST /eligibility_check

### Description
Submits a real-time 270/271 eligibility check to verify patient insurance coverage. This endpoint requires provider and subscriber information, along with the payer's trading partner service ID, to return detailed benefits information including coverage status, deductibles, copays, coinsurance rates, and out-of-pocket maximums.

### Method
POST

### Endpoint
/eligibility_check

### Parameters
#### Request Body
- **control_number** (string) - Required - A unique transaction identifier for the eligibility check.
- **trading_partner_service_id** (string) - Required - The service ID of the payer for the eligibility check (e.g., UnitedHealthcare).
- **provider** (object) - Required - Information about the healthcare provider.
  - **organization_name** (string) - Optional - The name of the healthcare organization.
  - **npi** (string) - Optional - The National Provider Identifier of the provider.
- **subscriber** (object) - Required - Information about the insurance subscriber.
  - **member_id** (string) - Optional - The member ID of the subscriber.
  - **first_name** (string) - Optional - The first name of the subscriber.
  - **last_name** (string) - Optional - The last name of the subscriber.
  - **date_of_birth** (string) - Optional - The date of birth of the subscriber in YYYYMMDD format.
- **encounter** (object) - Optional - Information about the healthcare encounter.
  - **service_type_codes** (array of enums) - Optional - A list of service type codes for the eligibility check. Example: `["HealthBenefitPlanCoverage"]`.

### Request Example
```json
{
  "control_number": "123456789",
  "trading_partner_service_id": "87726",
  "provider": {
    "organization_name": "ACME Health Services",
    "npi": "1234567890"
  },
  "subscriber": {
    "member_id": "UHC123456",
    "first_name": "Jane",
    "last_name": "Doe",
    "date_of_birth": "19800101"
  },
  "encounter": {
    "service_type_codes": [
      "HealthBenefitPlanCoverage"
    ]
  }
}
```

### Response
#### Success Response (200)
- **plan_status** (object) - Optional - The status of the patient's health plan.
- **subscriber** (object) - Optional - Detailed information about the subscriber, including group number.
- **benefits_information** (array of objects) - Optional - A list of benefit entries, each detailing benefit name, amount, and percentage.
- **errors** (array of objects) - Optional - A list of errors encountered during the eligibility check.

#### Response Example
```json
{
  "plan_status": {
    "coverage_level": "Individual",
    "coverage_status": "Active"
  },
  "subscriber": {
    "first_name": "Jane",
    "last_name": "Doe",
    "group_number": "G12345"
  },
  "benefits_information": [
    {
      "name": "Deductible",
      "benefit_amount": "500.00"
    },
    {
      "name": "Copay",
      "benefit_amount": "25.00"
    }
  ],
  "errors": []
}
```
```

--------------------------------

### Configure Rust Encounter for Eligibility Checks

Source: https://context7.com/sunnyhealthai/stedi-rs/llms.txt

Defines the `Encounter` struct in Rust for healthcare eligibility verification. It allows specifying service type codes, dates of service, and procedure codes to retrieve specific benefits information. The enum `RequestEligibilityServiceTypeCode` categorizes different healthcare services, while `EncounterProductOrServiceIdQualifier` can specify the type of procedure code used.

```rust
use stedi_rs::models::{Encounter, RequestEligibilityServiceTypeCode, MedicalProcedure};

// Basic encounter for general benefits
let general_encounter = Encounter {
    service_type_codes: Some(vec![
        RequestEligibilityServiceTypeCode::HealthBenefitPlanCoverage,  // Code 30
    ]),
    ..Default::default()
};

// Encounter for specific service type
let specialist_encounter = Encounter {
    service_type_codes: Some(vec![
        RequestEligibilityServiceTypeCode::ProfessionalPhysician,  // Code 96 (Specialist)
    ]),
    date_of_service: Some("20250115".to_string()),  // YYYYMMDD format
    ..Default::default()
};

// Encounter with multiple service types
let comprehensive_encounter = Encounter {
    service_type_codes: Some(vec![
        RequestEligibilityServiceTypeCode::HealthBenefitPlanCoverage,
        RequestEligibilityServiceTypeCode::MentalHealth,
        RequestEligibilityServiceTypeCode::Pharmacy,
        RequestEligibilityServiceTypeCode::DentalCare,
    ]),
    ..Default::default()
};

// Encounter with date range
let date_range_encounter = Encounter {
    service_type_codes: Some(vec![
        RequestEligibilityServiceTypeCode::Hospital,
    ]),
    beginning_date_of_service: Some("20250101".to_string()),
    end_date_of_service: Some("20250131".to_string()),
    ..Default::default()
};

// Encounter with procedure code (not all payers support this)
let procedure_encounter = Encounter {
    procedure_code: Some("99213".to_string()),  // CPT code
    product_or_service_id_qualifier: Some(
        stedi_rs::models::EncounterProductOrServiceIdQualifier::CurrentProceduralTerminologyCode
    ),
    ..Default::default()
};
```
Tokens:
Raw