textfsm-rust 0.3.1

//! # TextFSM
//!
//! A template-based state machine for parsing semi-formatted text.
//!
//! This is a Rust port of [Google's TextFSM](https://github.com/google/textfsm),
//! commonly used for parsing CLI output from network devices.
//!
//! ## Quick Start
//!
//! ```rust
//! use textfsm_rust::Template;
//!
//! let template_str = r#"Value Name (\S+)
//! Value Age (\d+)
//!
//! Start
//!   ^Name: ${Name}, Age: ${Age} -> Record
//! "#;
//!
//! let template = Template::parse_str(template_str).unwrap();
//! let mut parser = template.parser();
//!
//! let input = "Name: Alice, Age: 30\nName: Bob, Age: 25\n";
//! let results = parser.parse_text(input).unwrap();
//!
//! assert_eq!(results.len(), 2);
//! ```
//!
//! ## Template Syntax
//!
//! Templates consist of two sections:
//!
//! 1. **Value definitions** at the top:
//!    ```text
//!    Value [Options] Name (regex)
//!    ```
//!    Options: `Required`, `Filldown`, `Fillup`, `Key`, `List`
//!
//! 2. **State definitions** below (separated by blank line):
//!    ```text
//!    StateName
//!      ^pattern -> Action NewState
//!    ```
//!    Actions: `Next`, `Continue`, `Error`, `Record`, `Clear`, `Clearall`, `NoRecord`
//!
//! ## Compile-Time Template Validation
//!
//! Use the validation macros to catch template errors at compile time:
//!
//! ```rust,ignore
//! use textfsm_rust::{validate_template, validate_templates};
//!
//! // Validate a single template file
//! validate_template!("templates/cisco_show_version.textfsm");
//!
//! // Validate all .textfsm files in a directory
//! validate_templates!("templates/");
//! ```
//!
//! ## Serde Integration
//!
//! Enable the `serde` feature to deserialize parsed results directly into typed structs:
//!
//! ```toml
//! [dependencies]
//! textfsm-rust = { version = "0.1", features = ["serde"] }
//! ```
//!
//! ```rust,ignore
//! use textfsm_rust::{Deserialize, Template};
//!
//! #[derive(Deserialize, Debug)]
//! struct Interface {
//!     interface: String,
//!     status: String,
//! }
//!
//! let template = Template::parse_str(TEMPLATE)?;
//! let mut parser = template.parser();
//!
//! // Deserialize directly into typed structs
//! let interfaces: Vec<Interface> = parser.parse_text_into(input)?;
//! ```
//!
//! Field names are matched case-insensitively against template value names.
//!
//! ## Example Template
//!
//! ```text
//! Value Required Interface (\S+)
//! Value Filldown Status (up|down)
//! Value IPAddress (\d+\.\d+\.\d+\.\d+)
//!
//! Start
//!   ^Interface: ${Interface} -> Continue
//!   ^  Status: ${Status}
//!   ^  IP: ${IPAddress} -> Record
//! ```

// Re-export everything from textfsm-core
pub use textfsm_core::*;

// Re-export macros from textfsm-macros
pub use textfsm_macros::{validate_index, validate_template, validate_templates};

// Re-export serde's Deserialize trait when serde feature is enabled
#[cfg(feature = "serde")]
pub use serde::Deserialize;