use super::*;

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas aeruginosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "287.DR97_1";
/// let this_library_node_name2 = "287.DR97_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_aeruginosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_aeruginosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_aeruginosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_aeruginosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["287"]),
        None,
        Some("."),
        Some("DR97_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia cepacia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "292.DM42_1";
/// let this_library_node_name2 = "292.DM42_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_cepacia_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_cepacia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_cepacia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_cepacia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["292"]),
        None,
        Some("."),
        Some("DM42_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas oleovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "301.JNHE01000001_gene117";
/// let this_library_node_name2 = "301.JNHE01000105_gene2670";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_oleovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_oleovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_oleovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_oleovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["301"]),
        None,
        Some("."),
        Some("JNHE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas campestris campestris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "340.xcc-b100_0001";
/// let this_library_node_name2 = "340.xcc_try_5011";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_campestris_campestris_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_campestris_campestris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_campestris_campestris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_campestris_campestris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["340"]),
        None,
        Some("."),
        Some("xcc"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agrobacterium rhizogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "359.CN09_00005";
/// let this_library_node_name2 = "359.CN09_34620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agrobacterium_rhizogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_agrobacterium_rhizogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agrobacterium_rhizogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agrobacterium_rhizogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["359"]),
        None,
        Some("."),
        Some("CN09_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sinorhizobium fredii NGR234 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "394.NGR_a00010";
/// let this_library_node_name2 = "394.NGR_c37160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sinorhizobium_fredii_ngr234_node_name(this_library_node_name1));
/// assert!(is_valid_string_sinorhizobium_fredii_ngr234_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sinorhizobium_fredii_ngr234_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sinorhizobium_fredii_ngr234_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["394"]),
        None,
        Some("."),
        Some("NGR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter baumannii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "470.IX87_00020";
/// let this_library_node_name2 = "470.IX87_22095";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_baumannii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_baumannii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_baumannii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_baumannii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["470"]),
        None,
        Some("."),
        Some("IX87_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alcaligenes faecalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "511.JT27_00010";
/// let this_library_node_name2 = "511.JT27_20360";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alcaligenes_faecalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alcaligenes_faecalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alcaligenes_faecalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alcaligenes_faecalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["511"]),
        None,
        Some("."),
        Some("JT27_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea agglomerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "549.BW31_00004";
/// let this_library_node_name2 = "549.BW31_05003";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_agglomerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_agglomerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_agglomerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_agglomerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["549"]),
        None,
        Some("."),
        Some("BW31_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Klebsiella oxytoca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "571.MC52_00005";
/// let this_library_node_name2 = "571.MC52_30610";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_klebsiella_oxytoca_node_name(this_library_node_name1));
/// assert!(is_valid_string_klebsiella_oxytoca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_klebsiella_oxytoca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_klebsiella_oxytoca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["571"]),
        None,
        Some("."),
        Some("MC52_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Klebsiella pneumoniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "573.JG24_00005";
/// let this_library_node_name2 = "573.JG24_30595";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_klebsiella_pneumoniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_klebsiella_pneumoniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_klebsiella_pneumoniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_klebsiella_pneumoniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["573"]),
        None,
        Some("."),
        Some("JG24_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Proteus vulgaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585.DR95_1";
/// let this_library_node_name2 = "585.DR95_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_proteus_vulgaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_proteus_vulgaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_proteus_vulgaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_proteus_vulgaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585"]),
        None,
        Some("."),
        Some("DR95_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yersinia pseudotuberculosis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "633.DJ40_1";
/// let this_library_node_name2 = "633.DJ40_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yersinia_pseudotuberculosis_node_name(this_library_node_name1));
/// assert!(is_valid_string_yersinia_pseudotuberculosis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yersinia_pseudotuberculosis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yersinia_pseudotuberculosis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["633"]),
        None,
        Some("."),
        Some("DJ40_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio vulnificus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "672.VV93_v1c00010";
/// let this_library_node_name2 = "672.VV93_v1c45650";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_vulnificus_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_vulnificus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_vulnificus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_vulnificus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["672"]),
        None,
        Some("."),
        Some("VV93_v1c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pasteurella multocida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "747.DR93_10";
/// let this_library_node_name2 = "747.DR93_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pasteurella_multocida_node_name(this_library_node_name1));
/// assert!(is_valid_string_pasteurella_multocida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pasteurella_multocida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pasteurella_multocida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["747"]),
        None,
        Some("."),
        Some("DR93_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pasteurella pneumotropica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "758.BBIX01000001_gene1";
/// let this_library_node_name2 = "758.BBIX01000009_gene2213";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pasteurella_pneumotropica_node_name(this_library_node_name1));
/// assert!(is_valid_string_pasteurella_pneumotropica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pasteurella_pneumotropica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pasteurella_pneumotropica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["758"]),
        None,
        Some("."),
        Some("BBIX0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydia trachomatis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "813.O172_00005";
/// let this_library_node_name2 = "813.O172_04890";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydia_trachomatis_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydia_trachomatis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydia_trachomatis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydia_trachomatis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["813"]),
        None,
        Some("."),
        Some("O172_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter ureolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "827.JFJK01000001_gene742";
/// let this_library_node_name2 = "827.JFJK01000025_gene1296";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_ureolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_ureolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_ureolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_ureolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["827"]),
        None,
        Some("."),
        Some("JFJK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio vulgaris Hildenborough nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "882.DVU_0001";
/// let this_library_node_name2 = "882.DVU_3395";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_vulgaris_hildenborough_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_vulgaris_hildenborough_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_vulgaris_hildenborough_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_vulgaris_hildenborough_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["882"]),
        None,
        Some("."),
        Some("DVU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio vulgaris Miyazaki nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883.DvMF_0001";
/// let this_library_node_name2 = "883.DvMF_3206";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_vulgaris_miyazaki_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_vulgaris_miyazaki_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_vulgaris_miyazaki_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_vulgaris_miyazaki_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883"]),
        None,
        Some("."),
        Some("DvMF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium hydatis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "991.IW20_00005";
/// let this_library_node_name2 = "991.IW20_25950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_hydatis_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_hydatis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_hydatis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_hydatis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["991"]),
        None,
        Some("."),
        Some("IW20_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erythrobacter longus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1044.EH31_00005";
/// let this_library_node_name2 = "1044.EH31_17045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erythrobacter_longus_node_name(this_library_node_name1));
/// assert!(is_valid_string_erythrobacter_longus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erythrobacter_longus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erythrobacter_longus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1044"]),
        None,
        Some("."),
        Some("EH31_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus elongatus PCC7942 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1140.Synpcc7942_0001";
/// let this_library_node_name2 = "1140.Synpcc7942_B2664";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_elongatus_pcc7942_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_elongatus_pcc7942_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_elongatus_pcc7942_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_elongatus_pcc7942_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1140"]),
        None,
        Some("."),
        Some("Synpcc7942_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechocystis sp. PCC6714 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1147.D082_00010";
/// let this_library_node_name2 = "1147.D082_60500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechocystis_sp_pcc6714_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechocystis_sp_pcc6714_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechocystis_sp_pcc6714_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechocystis_sp_pcc6714_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1147"]),
        None,
        Some("."),
        Some("D082_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechocystis sp. PCC6803 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1148.1001103";
/// let this_library_node_name2 = "1148.1673361";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechocystis_sp_pcc6803_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechocystis_sp_pcc6803_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechocystis_sp_pcc6803_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechocystis_sp_pcc6803_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1148"]),
        None,
        Some("."),
        Some("1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leuconostoc lactis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1246.JMEA01000001_gene794";
/// let this_library_node_name2 = "1246.JMEA01000035_gene1599";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leuconostoc_lactis_node_name(this_library_node_name1));
/// assert!(is_valid_string_leuconostoc_lactis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leuconostoc_lactis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leuconostoc_lactis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1246"]),
        None,
        Some("."),
        Some("JMEA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dermacoccus nishinomiyaensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1274.HX89_00010";
/// let this_library_node_name2 = "1274.HX89_14655";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dermacoccus_nishinomiyaensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_dermacoccus_nishinomiyaensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dermacoccus_nishinomiyaensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dermacoccus_nishinomiyaensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1274"]),
        None,
        Some("."),
        Some("HX89_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus aureus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280.SAXN108_0001";
/// let this_library_node_name2 = "1280.SAXN108_2992";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_aureus_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_aureus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_aureus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_aureus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280"]),
        None,
        Some("."),
        Some("SAXN108_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus xylosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1288.SXYLSMQ121_0001";
/// let this_library_node_name2 = "1288.SXYLSMQ121_2514";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_xylosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_xylosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_xylosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_xylosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1288"]),
        None,
        Some("."),
        Some("SXYLSMQ121_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus pyogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1314.HKU360_00001";
/// let this_library_node_name2 = "1314.HKU360_01980";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_pyogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_pyogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_pyogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_pyogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1314"]),
        None,
        Some("."),
        Some("HKU360_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus iniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1346.DQ08_00005";
/// let this_library_node_name2 = "1346.DQ08_10240";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_iniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_iniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_iniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_iniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1346"]),
        None,
        Some("."),
        Some("DQ08_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus cereus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1396.DJ87_1";
/// let this_library_node_name2 = "1396.DJ87_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_cereus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_cereus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_cereus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_cereus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1396"]),
        None,
        Some("."),
        Some("DJ87_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus mycoides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1405.DJ92_1";
/// let this_library_node_name2 = "1405.DJ92_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_mycoides_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_mycoides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_mycoides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_mycoides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1405"]),
        None,
        Some("."),
        Some("DJ92_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. ATCC29733 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1507.HMPREF0262_00001";
/// let this_library_node_name2 = "1507.HMPREF0262_03743";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_atcc29733_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_atcc29733_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_atcc29733_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_atcc29733_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1507"]),
        None,
        Some("."),
        Some("HMPREF0262_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sticklandii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1511.CLOST_0001";
/// let this_library_node_name2 = "1511.CLOST_2590";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sticklandii_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sticklandii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sticklandii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sticklandii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1511"]),
        None,
        Some("."),
        Some("CLOST_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus animalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1605.Lani381_0001";
/// let this_library_node_name2 = "1605.Lani381_1844";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_animalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_animalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_animalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_animalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1605"]),
        None,
        Some("."),
        Some("Lani381_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium adolescentis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1680.BADO_0001";
/// let this_library_node_name2 = "1680.BADO_1745";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_adolescentis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_adolescentis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_adolescentis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_adolescentis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1680"]),
        None,
        Some("."),
        Some("BADO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium coryneforme nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1687.BCOR_0001";
/// let this_library_node_name2 = "1687.BCOR_1391";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_coryneforme_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_coryneforme_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_coryneforme_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_coryneforme_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1687"]),
        None,
        Some("."),
        Some("BCOR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium cuniculi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1688.BCUN_0001";
/// let this_library_node_name2 = "1688.BCUN_3456";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_cuniculi_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_cuniculi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_cuniculi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_cuniculi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1688"]),
        None,
        Some("."),
        Some("BCUN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium pseudolongum globosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1690.BPSG_0001";
/// let this_library_node_name2 = "1690.BPSG_3031";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_pseudolongum_globosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_pseudolongum_globosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_pseudolongum_globosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_pseudolongum_globosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1690"]),
        None,
        Some("."),
        Some("BPSG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium magnum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1692.BMAGN_0001";
/// let this_library_node_name2 = "1692.BMAGN_5010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_magnum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_magnum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_magnum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_magnum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1692"]),
        None,
        Some("."),
        Some("BMAGN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium minimum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1693.BMIN_0001";
/// let this_library_node_name2 = "1693.BMIN_3004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_minimum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_minimum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_minimum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_minimum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1693"]),
        None,
        Some("."),
        Some("BMIN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oerskovia turbata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1713.JOFV01000001_gene1795";
/// let this_library_node_name2 = "1713.JOFV01000072_gene1268";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oerskovia_turbata_node_name(this_library_node_name1));
/// assert!(is_valid_string_oerskovia_turbata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oerskovia_turbata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oerskovia_turbata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1713"]),
        None,
        Some("."),
        Some("JOFV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium pseudotuberculosis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1719.CPTC_00001";
/// let this_library_node_name2 = "1719.CPTC_02242";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_pseudotuberculosis_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_pseudotuberculosis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_pseudotuberculosis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_pseudotuberculosis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1719"]),
        None,
        Some("."),
        Some("CPTC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus fascians nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1828.JOKB01000001_gene1";
/// let this_library_node_name2 = "1828.JOKB01000067_gene3608";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_fascians_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_fascians_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_fascians_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_fascians_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1828"]),
        None,
        Some("."),
        Some("JOKB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinoplanes utahensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1869.MB27_00005";
/// let this_library_node_name2 = "1869.MB27_42870";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinoplanes_utahensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinoplanes_utahensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinoplanes_utahensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinoplanes_utahensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1869"]),
        None,
        Some("."),
        Some("MB27_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces aureofaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1894.JOER01000001_gene5148";
/// let this_library_node_name2 = "1894.JOER01000278_gene51";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_aureofaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_aureofaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_aureofaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_aureofaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1894"]),
        None,
        Some("."),
        Some("JOER01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces bikiniensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1896.JOAU01000001_gene4177";
/// let this_library_node_name2 = "1896.JOAU01000126_gene4686";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_bikiniensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_bikiniensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_bikiniensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_bikiniensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1896"]),
        None,
        Some("."),
        Some("JOAU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces fradiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1906.SFRA_00005";
/// let this_library_node_name2 = "1906.SFRA_33100";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_fradiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_fradiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_fradiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_fradiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1906"]),
        None,
        Some("."),
        Some("SFRA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces glaucescens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1907.SGLAU_00005";
/// let this_library_node_name2 = "1907.SGLAU_33360";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_glaucescens_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_glaucescens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_glaucescens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_glaucescens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1907"]),
        None,
        Some("."),
        Some("SGLAU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces halstedii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1944.JOAZ01000001_gene3955";
/// let this_library_node_name2 = "1944.JOAZ01000105_gene393";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_halstedii_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_halstedii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_halstedii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_halstedii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1944"]),
        None,
        Some("."),
        Some("JOAZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sclerotialus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1957.JODX01000001_gene4998";
/// let this_library_node_name2 = "1957.JODX01000090_gene157";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sclerotialus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sclerotialus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sclerotialus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sclerotialus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1957"]),
        None,
        Some("."),
        Some("JODX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces virginiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1961.JOAK01000001_gene2917";
/// let this_library_node_name2 = "1961.JOAK01000131_gene4247";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_virginiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_virginiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_virginiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_virginiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1961"]),
        None,
        Some("."),
        Some("JOAK01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces cellulosae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1968.JOEV01000001_gene7339";
/// let this_library_node_name2 = "1968.JOEV01000182_gene8490";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_cellulosae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_cellulosae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_cellulosae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_cellulosae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1968"]),
        None,
        Some("."),
        Some("JOEV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microtetraspora glauca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1996.JOFO01000001_gene3665";
/// let this_library_node_name2 = "1996.JOFO01000255_gene67";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microtetraspora_glauca_node_name(this_library_node_name1));
/// assert!(is_valid_string_microtetraspora_glauca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microtetraspora_glauca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microtetraspora_glauca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1996"]),
        None,
        Some("."),
        Some("JOFO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptosporangium amethystogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2002.JOEQ01000001_gene4608";
/// let this_library_node_name2 = "2002.JOEQ01000229_gene5903";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptosporangium_amethystogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptosporangium_amethystogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptosporangium_amethystogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptosporangium_amethystogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2002"]),
        None,
        Some("."),
        Some("JOEQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pimelobacter simplex nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2045.KR76_00005";
/// let this_library_node_name2 = "2045.KR76_27660";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pimelobacter_simplex_node_name(this_library_node_name1));
/// assert!(is_valid_string_pimelobacter_simplex_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pimelobacter_simplex_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pimelobacter_simplex_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2045"]),
        None,
        Some("."),
        Some("KR76_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia terrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2055.JNXA01000001_gene1654";
/// let this_library_node_name2 = "2055.JNXA01000108_gene1146";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_terrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_terrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_terrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_terrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2055"]),
        None,
        Some("."),
        Some("JNXA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudonocardia autotrophica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2074.JNYD01000001_gene5806";
/// let this_library_node_name2 = "2074.JNYD01000153_gene6764";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudonocardia_autotrophica_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudonocardia_autotrophica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudonocardia_autotrophica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudonocardia_autotrophica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2074"]),
        None,
        Some("."),
        Some("JNYD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma agalactiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2110.MAGa0010";
/// let this_library_node_name2 = "2110.MAGa8660";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_agalactiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_agalactiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_agalactiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_agalactiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2110"]),
        None,
        Some("."),
        Some("MAGa"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma californicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2113.MCFN_00005";
/// let this_library_node_name2 = "2113.MCFN_03445";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_californicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_californicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_californicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_californicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2113"]),
        None,
        Some("."),
        Some("MCFN_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoanaerobacter kivui nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2325.TKV_c00010";
/// let this_library_node_name2 = "2325.TKV_c24810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoanaerobacter_kivui_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoanaerobacter_kivui_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoanaerobacter_kivui_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoanaerobacter_kivui_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2325"]),
        None,
        Some("."),
        Some("TKV_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solemya velum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2340.JV46_00130";
/// let this_library_node_name2 = "2340.JV46_29920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solemya_velum_node_name(this_library_node_name1));
/// assert!(is_valid_string_solemya_velum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solemya_velum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solemya_velum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2340"]),
        None,
        Some("."),
        Some("JV46_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sodalis pierantonius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2342.SOPEG_0001";
/// let this_library_node_name2 = "2342.SOPEG_4147";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sodalis_pierantonius_node_name(this_library_node_name1));
/// assert!(is_valid_string_sodalis_pierantonius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sodalis_pierantonius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sodalis_pierantonius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2342"]),
        None,
        Some("."),
        Some("SOPEG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fervidobacterium islandicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2423.NA23_0200015";
/// let this_library_node_name2 = "2423.NA23_0211095";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fervidobacterium_islandicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_fervidobacterium_islandicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fervidobacterium_islandicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fervidobacterium_islandicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2423"]),
        None,
        Some("."),
        Some("NA23_02"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citrus sinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2711.XP_006464189.1";
/// let this_library_node_name2 = "2711.XP_006495493.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citrus_sinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_citrus_sinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citrus_sinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citrus_sinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2711"]),
        None,
        Some("."),
        Some("XP_0064"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synergistes jonesii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2754.EH55_00005";
/// let this_library_node_name2 = "2754.EH55_13750";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synergistes_jonesii_node_name(this_library_node_name1));
/// assert!(is_valid_string_synergistes_jonesii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synergistes_jonesii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synergistes_jonesii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2754"]),
        None,
        Some("."),
        Some("EH55_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phaeodactylum tricornutum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2850.Phatr10005";
/// let this_library_node_name2 = "2850.Phatrdraft998";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phaeodactylum_tricornutum_node_name(this_library_node_name1));
/// assert!(is_valid_string_phaeodactylum_tricornutum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phaeodactylum_tricornutum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phaeodactylum_tricornutum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2850"]),
        None,
        Some("."),
        Some("Phatr"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ectocarpus siliculosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2880.D1J6Z0";
/// let this_library_node_name2 = "2880.D8LUD3";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ectocarpus_siliculosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ectocarpus_siliculosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ectocarpus_siliculosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ectocarpus_siliculosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2880"]),
        None,
        Some("."),
        Some("D"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Emiliania huxleyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "2903.EOD03633";
/// let this_library_node_name2 = "2903.EOD42186";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_emiliania_huxleyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_emiliania_huxleyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_emiliania_huxleyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_emiliania_huxleyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["2903"]),
        None,
        Some("."),
        Some("EOD"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydomonas reinhardtii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3055.AAB93440";
/// let this_library_node_name2 = "3055.EDP10055";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydomonas_reinhardtii_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydomonas_reinhardtii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydomonas_reinhardtii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydomonas_reinhardtii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3055"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Volvox carteri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3067.XP_002945607.1";
/// let this_library_node_name2 = "3067.XP_002960042.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_volvox_carteri_node_name(this_library_node_name1));
/// assert!(is_valid_string_volvox_carteri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_volvox_carteri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_volvox_carteri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3067"]),
        None,
        Some("."),
        Some("XP_0029"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Auxenochlorella protothecoides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3075.A0A023HHU2";
/// let this_library_node_name2 = "3075.V5NG01";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_auxenochlorella_protothecoides_node_name(this_library_node_name1));
/// assert!(is_valid_string_auxenochlorella_protothecoides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_auxenochlorella_protothecoides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_auxenochlorella_protothecoides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3075"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Physcomitrella patens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3218.PP1S10008_1V6.1";
/// let this_library_node_name2 = "3218.PP1S9_9V6.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_physcomitrella_patens_node_name(this_library_node_name1));
/// assert!(is_valid_string_physcomitrella_patens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_physcomitrella_patens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_physcomitrella_patens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3218"]),
        None,
        Some("."),
        Some("PP1S"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Theobroma cacao nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3641.EOX90563";
/// let this_library_node_name2 = "3641.EOY34749";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_theobroma_cacao_node_name(this_library_node_name1));
/// assert!(is_valid_string_theobroma_cacao_node_name(this_library_node_name2));
/// assert!(!is_valid_string_theobroma_cacao_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_theobroma_cacao_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3641"]),
        None,
        Some("."),
        Some("EO"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carica papaya nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3649.evm.TU.contig_23646.1";
/// let this_library_node_name2 = "3649.evm.model.supercontig_999.5";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carica_papaya_node_name(this_library_node_name1));
/// assert!(is_valid_string_carica_papaya_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carica_papaya_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carica_papaya_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3649"]),
        None,
        Some("."),
        Some("evm"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cucumis melo nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3656.XP_008436961.1";
/// let this_library_node_name2 = "3656.XP_008467330.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cucumis_melo_node_name(this_library_node_name1));
/// assert!(is_valid_string_cucumis_melo_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cucumis_melo_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cucumis_melo_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3656"]),
        None,
        Some("."),
        Some("XP_0084"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cucumis sativus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3659.XP_004133701.1";
/// let this_library_node_name2 = "3659.XP_004174200.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cucumis_sativus_node_name(this_library_node_name1));
/// assert!(is_valid_string_cucumis_sativus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cucumis_sativus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cucumis_sativus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3659"]),
        None,
        Some("."),
        Some("XP_0041"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Populus trichocarpa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3694.POPTR_0001s00200.1";
/// let this_library_node_name2 = "3694.POPTR_3119s00200.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_populus_trichocarpa_node_name(this_library_node_name1));
/// assert!(is_valid_string_populus_trichocarpa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_populus_trichocarpa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_populus_trichocarpa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3694"]),
        None,
        Some("."),
        Some("POPTR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arabidopsis thaliana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3702.AT1G01010.1";
/// let this_library_node_name2 = "3702.ATMG01410.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arabidopsis_thaliana_node_name(this_library_node_name1));
/// assert!(is_valid_string_arabidopsis_thaliana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arabidopsis_thaliana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arabidopsis_thaliana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3702"]),
        None,
        Some("."),
        Some("AT"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brassica rapa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3711.Bra000001.1-P";
/// let this_library_node_name2 = "3711.Bra041174.1-P";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brassica_rapa_node_name(this_library_node_name1));
/// assert!(is_valid_string_brassica_rapa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brassica_rapa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brassica_rapa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3711"]),
        None,
        Some("."),
        Some("Bra0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brassica oleracea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3712.Bo00285s010.1";
/// let this_library_node_name2 = "3712.Bo9g186210.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brassica_oleracea_node_name(this_library_node_name1));
/// assert!(is_valid_string_brassica_oleracea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brassica_oleracea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brassica_oleracea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3712"]),
        None,
        Some("."),
        Some("Bo"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Malus domestica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3750.XP_008336897.1";
/// let this_library_node_name2 = "3750.XP_008394331.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_malus_domestica_node_name(this_library_node_name1));
/// assert!(is_valid_string_malus_domestica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_malus_domestica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_malus_domestica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3750"]),
        None,
        Some("."),
        Some("XP_0083"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prunus persica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3760.EMJ00001";
/// let this_library_node_name2 = "3760.EMJ28927";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prunus_persica_node_name(this_library_node_name1));
/// assert!(is_valid_string_prunus_persica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prunus_persica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prunus_persica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3760"]),
        None,
        Some("."),
        Some("EMJ"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cicer arietinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3827.XP_004485403.1";
/// let this_library_node_name2 = "3827.XP_004517314.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cicer_arietinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_cicer_arietinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cicer_arietinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cicer_arietinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3827"]),
        None,
        Some("."),
        Some("XP_004"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glycine max nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3847.GLYMA0002S50.1";
/// let this_library_node_name2 = "3847.GLYMA2269S00200.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glycine_max_node_name(this_library_node_name1));
/// assert!(is_valid_string_glycine_max_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glycine_max_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glycine_max_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3847"]),
        None,
        Some("."),
        Some("GLYMA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Medicago truncatula nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3880.AES58510";
/// let this_library_node_name2 = "3880.AET05652";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_medicago_truncatula_node_name(this_library_node_name1));
/// assert!(is_valid_string_medicago_truncatula_node_name(this_library_node_name2));
/// assert!(!is_valid_string_medicago_truncatula_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_medicago_truncatula_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3880"]),
        None,
        Some("."),
        Some("AE"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phaseolus vulgaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3885.XP_007131274.1";
/// let this_library_node_name2 = "3885.XP_007163993.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phaseolus_vulgaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_phaseolus_vulgaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phaseolus_vulgaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phaseolus_vulgaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3885"]),
        None,
        Some("."),
        Some("XP_0071"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Manihot esculenta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3983.cassava4.1_000001m";
/// let this_library_node_name2 = "3983.cassava4.1_034469m";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_manihot_esculenta_node_name(this_library_node_name1));
/// assert!(is_valid_string_manihot_esculenta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_manihot_esculenta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_manihot_esculenta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3983"]),
        None,
        Some("."),
        Some("cassava4"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ricinus communis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "3988.XP_002509419.1";
/// let this_library_node_name2 = "3988.XP_002540639.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ricinus_communis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ricinus_communis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ricinus_communis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ricinus_communis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["3988"]),
        None,
        Some("."),
        Some("XP_0025"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Linum usitatissimum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4006.Lus10000001";
/// let this_library_node_name2 = "4006.Lus10043484";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_linum_usitatissimum_node_name(this_library_node_name1));
/// assert!(is_valid_string_linum_usitatissimum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_linum_usitatissimum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_linum_usitatissimum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4006"]),
        None,
        Some("."),
        Some("Lus100"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solanum lycopersicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4081.Solyc00g005000.2.1";
/// let this_library_node_name2 = "4081.Solyc12g100360.1.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solanum_lycopersicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_solanum_lycopersicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solanum_lycopersicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solanum_lycopersicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4081"]),
        None,
        Some("."),
        Some("Solyc"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nicotiana sylvestris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4096.XP_009757019.1";
/// let this_library_node_name2 = "4096.XP_009805077.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nicotiana_sylvestris_node_name(this_library_node_name1));
/// assert!(is_valid_string_nicotiana_sylvestris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nicotiana_sylvestris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nicotiana_sylvestris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4096"]),
        None,
        Some("."),
        Some("XP_009"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nicotiana tomentosiformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4098.XP_009586566.1";
/// let this_library_node_name2 = "4098.XP_009632064.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nicotiana_tomentosiformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nicotiana_tomentosiformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nicotiana_tomentosiformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nicotiana_tomentosiformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4098"]),
        None,
        Some("."),
        Some("XP_009"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solanum tuberosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4113.PGSC0003DMT400000002";
/// let this_library_node_name2 = "4113.PGSC0003DMT400097780";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solanum_tuberosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_solanum_tuberosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solanum_tuberosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solanum_tuberosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4113"]),
        None,
        Some("."),
        Some("PGSC0003DMT4000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erythranthe guttata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4155.Migut.A00001.1.p";
/// let this_library_node_name2 = "4155.Migut.O00981.1.p";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erythranthe_guttata_node_name(this_library_node_name1));
/// assert!(is_valid_string_erythranthe_guttata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erythranthe_guttata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erythranthe_guttata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4155"]),
        None,
        Some("."),
        Some("Migut"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nelumbo nucifera nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4432.XP_010240801.1";
/// let this_library_node_name2 = "4432.XP_010279676.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nelumbo_nucifera_node_name(this_library_node_name1));
/// assert!(is_valid_string_nelumbo_nucifera_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nelumbo_nucifera_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nelumbo_nucifera_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4432"]),
        None,
        Some("."),
        Some("XP_0102"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hordeum vulgare nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4513.AGP50735";
/// let this_library_node_name2 = "4513.MLOC_9998.3";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hordeum_vulgare_node_name(this_library_node_name1));
/// assert!(is_valid_string_hordeum_vulgare_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hordeum_vulgare_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hordeum_vulgare_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4513"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryza rufipogon nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4529.ORUFI01G00010.1";
/// let this_library_node_name2 = "4529.ORUFI12G22660.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryza_rufipogon_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryza_rufipogon_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryza_rufipogon_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryza_rufipogon_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4529"]),
        None,
        Some("."),
        Some("ORUFI"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryza sativa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4530.OS01T0100100-01";
/// let this_library_node_name2 = "4530.OS12T0641500-02";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryza_sativa_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryza_sativa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryza_sativa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryza_sativa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4530"]),
        None,
        Some("."),
        Some("OS"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryza brachyantha nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4533.OB0037G10010.1";
/// let this_library_node_name2 = "4533.OB12G27120.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryza_brachyantha_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryza_brachyantha_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryza_brachyantha_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryza_brachyantha_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4533"]),
        None,
        Some("."),
        Some("OB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryza nivara nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4536.ONIVA01G00010.1";
/// let this_library_node_name2 = "4536.ONIVA12G18990.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryza_nivara_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryza_nivara_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryza_nivara_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryza_nivara_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4536"]),
        None,
        Some("."),
        Some("ONIVA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryza punctata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4537.OPUNC01G00010.2";
/// let this_library_node_name2 = "4537.OPUNC12G18640.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryza_punctata_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryza_punctata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryza_punctata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryza_punctata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4537"]),
        None,
        Some("."),
        Some("OPUNC"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryza glaberrima nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4538.ORGLA01G0000100.1";
/// let this_library_node_name2 = "4538.ORGLA12G0207900.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryza_glaberrima_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryza_glaberrima_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryza_glaberrima_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryza_glaberrima_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4538"]),
        None,
        Some("."),
        Some("ORGLA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Setaria italica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4555.Si000001m";
/// let this_library_node_name2 = "4555.Si040879m";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_setaria_italica_node_name(this_library_node_name1));
/// assert!(is_valid_string_setaria_italica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_setaria_italica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_setaria_italica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4555"]),
        None,
        Some("."),
        Some("Si0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sorghum bicolor nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4558.Sb0010s002010.1";
/// let this_library_node_name2 = "4558.Sb3276s002010.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sorghum_bicolor_node_name(this_library_node_name1));
/// assert!(is_valid_string_sorghum_bicolor_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sorghum_bicolor_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sorghum_bicolor_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4558"]),
        None,
        Some("."),
        Some("Sb"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Triticum aestivum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4565.EPlTAEP00000010001";
/// let this_library_node_name2 = "4565.Traes_7DS_FFE9ACDAB.2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_triticum_aestivum_node_name(this_library_node_name1));
/// assert!(is_valid_string_triticum_aestivum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_triticum_aestivum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_triticum_aestivum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4565"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Triticum urartu nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4572.AGP51203";
/// let this_library_node_name2 = "4572.TRIUR3_35473-P1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_triticum_urartu_node_name(this_library_node_name1));
/// assert!(is_valid_string_triticum_urartu_node_name(this_library_node_name2));
/// assert!(!is_valid_string_triticum_urartu_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_triticum_urartu_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4572"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zea mays nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4577.AC148152.3_FGP001";
/// let this_library_node_name2 = "4577.GRMZM6G998221_P01";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zea_mays_node_name(this_library_node_name1));
/// assert!(is_valid_string_zea_mays_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zea_mays_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zea_mays_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4577"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Musa acuminata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4641.GSMUA_Achr10P00010_001";
/// let this_library_node_name2 = "4641.GSMUA_AchrUn_randomP29270_001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_musa_acuminata_node_name(this_library_node_name1));
/// assert!(is_valid_string_musa_acuminata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_musa_acuminata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_musa_acuminata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4641"]),
        None,
        Some("."),
        Some("GSMUA_Achr"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytophthora infestans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4787.PITG_00002T0";
/// let this_library_node_name2 = "4787.PITG_23351T0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytophthora_infestans_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytophthora_infestans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytophthora_infestans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytophthora_infestans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4787"]),
        None,
        Some("."),
        Some("PITG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytophthora parasitica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4792.ETI29616";
/// let this_library_node_name2 = "4792.ETI57732";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytophthora_parasitica_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytophthora_parasitica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytophthora_parasitica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytophthora_parasitica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4792"]),
        None,
        Some("."),
        Some("ETI"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Schizosaccharomyces pombe nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4896.SPAC1002.01.1";
/// let this_library_node_name2 = "4896.SPMTR.04.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_schizosaccharomyces_pombe_node_name(this_library_node_name1));
/// assert!(is_valid_string_schizosaccharomyces_pombe_node_name(this_library_node_name2));
/// assert!(!is_valid_string_schizosaccharomyces_pombe_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_schizosaccharomyces_pombe_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4896"]),
        None,
        Some("."),
        Some("SP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Schizosaccharomyces japonicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4897.EEB04996";
/// let this_library_node_name2 = "4897.EQC53077";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_schizosaccharomyces_japonicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_schizosaccharomyces_japonicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_schizosaccharomyces_japonicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_schizosaccharomyces_japonicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4897"]),
        None,
        Some("."),
        Some("E"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Schizosaccharomyces octosporus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4899.EPX70414";
/// let this_library_node_name2 = "4899.EPX75399";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_schizosaccharomyces_octosporus_node_name(this_library_node_name1));
/// assert!(is_valid_string_schizosaccharomyces_octosporus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_schizosaccharomyces_octosporus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_schizosaccharomyces_octosporus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4899"]),
        None,
        Some("."),
        Some("EPX7"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pichia kudriavzevii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4909.A0A099NHS3";
/// let this_library_node_name2 = "4909.Q8NJ70";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pichia_kudriavzevii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pichia_kudriavzevii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pichia_kudriavzevii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pichia_kudriavzevii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4909"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Millerozyma farinosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4920.XP_004194255.1";
/// let this_library_node_name2 = "4920.XP_004205429.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_millerozyma_farinosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_millerozyma_farinosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_millerozyma_farinosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_millerozyma_farinosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4920"]),
        None,
        Some("."),
        Some("XP_004"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Komagataella pastoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4922.CAY67059";
/// let this_library_node_name2 = "4922.CAY72203";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_komagataella_pastoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_komagataella_pastoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_komagataella_pastoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_komagataella_pastoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4922"]),
        None,
        Some("."),
        Some("CAY"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Scheffersomyces stipitis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4924.XP_001382228.2";
/// let this_library_node_name2 = "4924.XP_001388043.2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_scheffersomyces_stipitis_node_name(this_library_node_name1));
/// assert!(is_valid_string_scheffersomyces_stipitis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_scheffersomyces_stipitis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_scheffersomyces_stipitis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4924"]),
        None,
        Some("."),
        Some("XP_00138"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Meyerozyma guilliermondii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4929.XP_001481908.1";
/// let this_library_node_name2 = "4929.XP_001487827.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_meyerozyma_guilliermondii_node_name(this_library_node_name1));
/// assert!(is_valid_string_meyerozyma_guilliermondii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_meyerozyma_guilliermondii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_meyerozyma_guilliermondii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4929"]),
        None,
        Some("."),
        Some("XP_00148"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharomyces cerevisiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4932.Q0010";
/// let this_library_node_name2 = "4932.YPR204W";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharomyces_cerevisiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharomyces_cerevisiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharomyces_cerevisiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharomyces_cerevisiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4932"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Torulaspora delbrueckii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4950.XP_003678553.1";
/// let this_library_node_name2 = "4950.XP_003683524.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_torulaspora_delbrueckii_node_name(this_library_node_name1));
/// assert!(is_valid_string_torulaspora_delbrueckii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_torulaspora_delbrueckii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_torulaspora_delbrueckii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4950"]),
        None,
        Some("."),
        Some("XP_0036"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yarrowia lipolytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4952.CAG77606";
/// let this_library_node_name2 = "4952.CAR65214";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yarrowia_lipolytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_yarrowia_lipolytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yarrowia_lipolytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yarrowia_lipolytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4952"]),
        None,
        Some("."),
        Some("CA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zygosaccharomyces rouxii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4956.XP_002494383.1";
/// let this_library_node_name2 = "4956.XP_002499373.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zygosaccharomyces_rouxii_node_name(this_library_node_name1));
/// assert!(is_valid_string_zygosaccharomyces_rouxii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zygosaccharomyces_rouxii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zygosaccharomyces_rouxii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4956"]),
        None,
        Some("."),
        Some("XP_00249"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Debaryomyces hansenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "4959.XP_002769948.1";
/// let this_library_node_name2 = "4959.XP_462641.2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_debaryomyces_hansenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_debaryomyces_hansenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_debaryomyces_hansenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_debaryomyces_hansenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["4959"]),
        None,
        Some("."),
        Some("XP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Taphrina deformans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5011.R4X690";
/// let this_library_node_name2 = "5011.S0F3Q3";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_taphrina_deformans_node_name(this_library_node_name1));
/// assert!(is_valid_string_taphrina_deformans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_taphrina_deformans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_taphrina_deformans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5011"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bipolaris maydis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5016.M2SGY2";
/// let this_library_node_name2 = "5016.P40633";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bipolaris_maydis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bipolaris_maydis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bipolaris_maydis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bipolaris_maydis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5016"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bipolaris zeicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5017.XP_007706259.1";
/// let this_library_node_name2 = "5017.XP_007719111.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bipolaris_zeicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_bipolaris_zeicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bipolaris_zeicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bipolaris_zeicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5017"]),
        None,
        Some("."),
        Some("XP_0077"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptosphaeria maculans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5022.CBX89937";
/// let this_library_node_name2 = "5022.CBY02476";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptosphaeria_maculans_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptosphaeria_maculans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptosphaeria_maculans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptosphaeria_maculans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5022"]),
        None,
        Some("."),
        Some("CB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Histoplasma capsulatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5037.XP_001535740.1";
/// let this_library_node_name2 = "5037.XP_001545052.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_histoplasma_capsulatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_histoplasma_capsulatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_histoplasma_capsulatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_histoplasma_capsulatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5037"]),
        None,
        Some("."),
        Some("XP_0015"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blastomyces dermatitidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5039.XP_002620051.1";
/// let this_library_node_name2 = "5039.XP_002629637.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blastomyces_dermatitidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_blastomyces_dermatitidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blastomyces_dermatitidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blastomyces_dermatitidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5039"]),
        None,
        Some("."),
        Some("XP_00262"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aspergillus clavatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5057.CADACLAP00000001";
/// let this_library_node_name2 = "5057.CADACLAP00009144";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aspergillus_clavatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_aspergillus_clavatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aspergillus_clavatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aspergillus_clavatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5057"]),
        None,
        Some("."),
        Some("CADACLAP0000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aspergillus flavus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5059.CADAFLAP00000001";
/// let this_library_node_name2 = "5059.CADAFLAP00013487";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aspergillus_flavus_node_name(this_library_node_name1));
/// assert!(is_valid_string_aspergillus_flavus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aspergillus_flavus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aspergillus_flavus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5059"]),
        None,
        Some("."),
        Some("CADAFLAP000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aspergillus niger nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5061.CADANGAP00000001";
/// let this_library_node_name2 = "5061.CADANGAP00014097";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aspergillus_niger_node_name(this_library_node_name1));
/// assert!(is_valid_string_aspergillus_niger_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aspergillus_niger_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aspergillus_niger_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5061"]),
        None,
        Some("."),
        Some("CADANGAP000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aspergillus oryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5062.CADAORAP00000001";
/// let this_library_node_name2 = "5062.CADAORAP00012074";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aspergillus_oryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_aspergillus_oryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aspergillus_oryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aspergillus_oryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5062"]),
        None,
        Some("."),
        Some("CADAORAP000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Claviceps purpurea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5111.M1VTS6";
/// let this_library_node_name2 = "5111.Q9C141";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_claviceps_purpurea_node_name(this_library_node_name1));
/// assert!(is_valid_string_claviceps_purpurea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_claviceps_purpurea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_claviceps_purpurea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5111"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusarium fujikuroi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5127.CCT61437";
/// let this_library_node_name2 = "5127.CCT76281";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusarium_fujikuroi_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusarium_fujikuroi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusarium_fujikuroi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusarium_fujikuroi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5127"]),
        None,
        Some("."),
        Some("CCT"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neurospora crassa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5141.EFNCRP00000000001";
/// let this_library_node_name2 = "5141.EFNCRP00000009839";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neurospora_crassa_node_name(this_library_node_name1));
/// assert!(is_valid_string_neurospora_crassa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neurospora_crassa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neurospora_crassa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5141"]),
        None,
        Some("."),
        Some("EFNCRP0000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Podospora anserina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5145.XP_001902989.1";
/// let this_library_node_name2 = "5145.XP_003437544.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_podospora_anserina_node_name(this_library_node_name1));
/// assert!(is_valid_string_podospora_anserina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_podospora_anserina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_podospora_anserina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5145"]),
        None,
        Some("."),
        Some("XP_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sordaria macrospora nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5147.XP_003342368.1";
/// let this_library_node_name2 = "5147.XP_003353194.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sordaria_macrospora_node_name(this_library_node_name1));
/// assert!(is_valid_string_sordaria_macrospora_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sordaria_macrospora_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sordaria_macrospora_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5147"]),
        None,
        Some("."),
        Some("XP_0033"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sclerotinia sclerotiorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5180.EDN90601";
/// let this_library_node_name2 = "5180.EDO05047";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sclerotinia_sclerotiorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_sclerotinia_sclerotiorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sclerotinia_sclerotiorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sclerotinia_sclerotiorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5180"]),
        None,
        Some("."),
        Some("ED"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cryptococcus neoformans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5207.AAW40616";
/// let this_library_node_name2 = "5207.AAW47229";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cryptococcus_neoformans_node_name(this_library_node_name1));
/// assert!(is_valid_string_cryptococcus_neoformans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cryptococcus_neoformans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cryptococcus_neoformans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5207"]),
        None,
        Some("."),
        Some("AAW4"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tremella mesenterica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5217.XP_007000396.1";
/// let this_library_node_name2 = "5217.XP_007008703.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tremella_mesenterica_node_name(this_library_node_name1));
/// assert!(is_valid_string_tremella_mesenterica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tremella_mesenterica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tremella_mesenterica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5217"]),
        None,
        Some("."),
        Some("XP_00700"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ustilago maydis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5270.UM00001P0";
/// let this_library_node_name2 = "5270.UM06522P0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ustilago_maydis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ustilago_maydis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ustilago_maydis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ustilago_maydis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5270"]),
        None,
        Some("."),
        Some("UM0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodosporidium toruloides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5286.M7WCF1";
/// let this_library_node_name2 = "5286.M7Y0U0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodosporidium_toruloides_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodosporidium_toruloides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodosporidium_toruloides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodosporidium_toruloides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5286"]),
        None,
        Some("."),
        Some("M7"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Puccinia graminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5297.GMQ_00001T0";
/// let this_library_node_name2 = "5297.GMQ_27758T0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_puccinia_graminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_puccinia_graminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_puccinia_graminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_puccinia_graminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5297"]),
        None,
        Some("."),
        Some("GMQ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Schizophyllum commune nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5334.XP_003025854.1";
/// let this_library_node_name2 = "5334.XP_003039047.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_schizophyllum_commune_node_name(this_library_node_name1));
/// assert!(is_valid_string_schizophyllum_commune_node_name(this_library_node_name2));
/// assert!(!is_valid_string_schizophyllum_commune_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_schizophyllum_commune_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5334"]),
        None,
        Some("."),
        Some("XP_0030"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agaricus bisporus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5341.XP_007324908.1";
/// let this_library_node_name2 = "5341.XP_007336185.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agaricus_bisporus_node_name(this_library_node_name1));
/// assert!(is_valid_string_agaricus_bisporus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agaricus_bisporus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agaricus_bisporus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5341"]),
        None,
        Some("."),
        Some("XP_0073"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coprinopsis cinerea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5346.XP_001828127.2";
/// let this_library_node_name2 = "5346.XP_002912281.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coprinopsis_cinerea_node_name(this_library_node_name1));
/// assert!(is_valid_string_coprinopsis_cinerea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coprinopsis_cinerea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coprinopsis_cinerea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5346"]),
        None,
        Some("."),
        Some("XP_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Colletotrichum orbiculare nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5465.ENH75995";
/// let this_library_node_name2 = "5465.ENH89340";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_colletotrichum_orbiculare_node_name(this_library_node_name1));
/// assert!(is_valid_string_colletotrichum_orbiculare_node_name(this_library_node_name2));
/// assert!(!is_valid_string_colletotrichum_orbiculare_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_colletotrichum_orbiculare_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5465"]),
        None,
        Some("."),
        Some("ENH"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Candida albicans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5476.C4YCL4";
/// let this_library_node_name2 = "5476.Q9P4E9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_candida_albicans_node_name(this_library_node_name1));
/// assert!(is_valid_string_candida_albicans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_candida_albicans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_candida_albicans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5476"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Candida glabrata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5478.XP_002999509.1";
/// let this_library_node_name2 = "5478.XP_449958.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_candida_glabrata_node_name(this_library_node_name1));
/// assert!(is_valid_string_candida_glabrata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_candida_glabrata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_candida_glabrata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5478"]),
        None,
        Some("."),
        Some("XP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Candida maltosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5479.M3HD63";
/// let this_library_node_name2 = "5479.M3K8H0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_candida_maltosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_candida_maltosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_candida_maltosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_candida_maltosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5479"]),
        None,
        Some("."),
        Some("M3"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Candida parapsilosis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5480.G8B4P6";
/// let this_library_node_name2 = "5480.G8BLA5";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_candida_parapsilosis_node_name(this_library_node_name1));
/// assert!(is_valid_string_candida_parapsilosis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_candida_parapsilosis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_candida_parapsilosis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5480"]),
        None,
        Some("."),
        Some("G8B"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Candida tropicalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5482.XP_002545220.1";
/// let this_library_node_name2 = "5482.XP_002551473.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_candida_tropicalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_candida_tropicalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_candida_tropicalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_candida_tropicalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5482"]),
        None,
        Some("."),
        Some("XP_0025"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coccidioides immitis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5501.XP_001238839.1";
/// let this_library_node_name2 = "5501.XP_001249295.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coccidioides_immitis_node_name(this_library_node_name1));
/// assert!(is_valid_string_coccidioides_immitis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coccidioides_immitis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coccidioides_immitis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5501"]),
        None,
        Some("."),
        Some("XP_0012"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusarium oxysporum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5507.FOXG_00001P0";
/// let this_library_node_name2 = "5507.FOXG_17781P0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusarium_oxysporum_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusarium_oxysporum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusarium_oxysporum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusarium_oxysporum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5507"]),
        None,
        Some("."),
        Some("FOXG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusarium graminearum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5518.FGSG_00001P0";
/// let this_library_node_name2 = "5518.FGSG_14038P0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusarium_graminearum_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusarium_graminearum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusarium_graminearum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusarium_graminearum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5518"]),
        None,
        Some("."),
        Some("FGSG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichophyton rubrum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5551.XP_003230851.1";
/// let this_library_node_name2 = "5551.XP_003239556.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichophyton_rubrum_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichophyton_rubrum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichophyton_rubrum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichophyton_rubrum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5551"]),
        None,
        Some("."),
        Some("XP_00323"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leishmania major nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5664.LmjF.01.0010";
/// let this_library_node_name2 = "5664.LmjF.36.7000";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leishmania_major_node_name(this_library_node_name1));
/// assert!(is_valid_string_leishmania_major_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leishmania_major_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leishmania_major_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5664"]),
        None,
        Some("."),
        Some("LmjF"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leishmania infantum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5671.XP_001462615.1";
/// let this_library_node_name2 = "5671.XP_003888469.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leishmania_infantum_node_name(this_library_node_name1));
/// assert!(is_valid_string_leishmania_infantum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leishmania_infantum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leishmania_infantum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5671"]),
        None,
        Some("."),
        Some("XP_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leishmania panamensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5679.XP_010696644.1";
/// let this_library_node_name2 = "5679.XP_010704391.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leishmania_panamensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_leishmania_panamensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leishmania_panamensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leishmania_panamensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5679"]),
        None,
        Some("."),
        Some("XP_010"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trypanosoma brucei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5691.AAQ15496";
/// let this_library_node_name2 = "5691.EAN80686";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trypanosoma_brucei_node_name(this_library_node_name1));
/// assert!(is_valid_string_trypanosoma_brucei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trypanosoma_brucei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trypanosoma_brucei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5691"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trypanosoma cruzi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5693.XP_802133.1";
/// let this_library_node_name2 = "5693.XP_822144.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trypanosoma_cruzi_node_name(this_library_node_name1));
/// assert!(is_valid_string_trypanosoma_cruzi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trypanosoma_cruzi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trypanosoma_cruzi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5693"]),
        None,
        Some("."),
        Some("XP_8"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichomonas vaginalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5722.XP_001276801.1";
/// let this_library_node_name2 = "5722.XP_001584538.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichomonas_vaginalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichomonas_vaginalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichomonas_vaginalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichomonas_vaginalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5722"]),
        None,
        Some("."),
        Some("XP_001"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Giardia intestinalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5741.EDO76151";
/// let this_library_node_name2 = "5741.EFD95701";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_giardia_intestinalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_giardia_intestinalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_giardia_intestinalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_giardia_intestinalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5741"]),
        None,
        Some("."),
        Some("E"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Entamoeba histolytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5759.rna_EHI_000010-1";
/// let this_library_node_name2 = "5759.rna_EHI_201420-1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_entamoeba_histolytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_entamoeba_histolytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_entamoeba_histolytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_entamoeba_histolytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5759"]),
        None,
        Some("."),
        Some("rna_EHI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Naegleria gruberi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5762.XP_002667930.1";
/// let this_library_node_name2 = "5762.XP_002683640.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_naegleria_gruberi_node_name(this_library_node_name1));
/// assert!(is_valid_string_naegleria_gruberi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_naegleria_gruberi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_naegleria_gruberi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5762"]),
        None,
        Some("."),
        Some("XP_0026"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dictyostelium purpureum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5786.XP_003282853.1";
/// let this_library_node_name2 = "5786.XP_003295251.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dictyostelium_purpureum_node_name(this_library_node_name1));
/// assert!(is_valid_string_dictyostelium_purpureum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dictyostelium_purpureum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dictyostelium_purpureum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5786"]),
        None,
        Some("."),
        Some("XP_0032"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cryptosporidium muris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5808.XP_002139046.1";
/// let this_library_node_name2 = "5808.XP_002142979.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cryptosporidium_muris_node_name(this_library_node_name1));
/// assert!(is_valid_string_cryptosporidium_muris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cryptosporidium_muris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cryptosporidium_muris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5808"]),
        None,
        Some("."),
        Some("XP_0021"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Toxoplasma gondii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5811.TGME49_000010";
/// let this_library_node_name2 = "5811.TGME49_121700";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_toxoplasma_gondii_node_name(this_library_node_name1));
/// assert!(is_valid_string_toxoplasma_gondii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_toxoplasma_gondii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_toxoplasma_gondii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5811"]),
        None,
        Some("."),
        Some("TGME49_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Plasmodium berghei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5821.PBANKA_000010";
/// let this_library_node_name2 = "5821.PBNAKA_083685.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_plasmodium_berghei_node_name(this_library_node_name1));
/// assert!(is_valid_string_plasmodium_berghei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_plasmodium_berghei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_plasmodium_berghei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5821"]),
        None,
        Some("."),
        Some("PB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Plasmodium chabaudi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5825.PCHAS_000010";
/// let this_library_node_name2 = "5825.PCHAS_146880";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_plasmodium_chabaudi_node_name(this_library_node_name1));
/// assert!(is_valid_string_plasmodium_chabaudi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_plasmodium_chabaudi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_plasmodium_chabaudi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5825"]),
        None,
        Some("."),
        Some("PCHAS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Plasmodium cynomolgi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5827.XP_004220499.1";
/// let this_library_node_name2 = "5827.XP_004228329.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_plasmodium_cynomolgi_node_name(this_library_node_name1));
/// assert!(is_valid_string_plasmodium_cynomolgi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_plasmodium_cynomolgi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_plasmodium_cynomolgi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5827"]),
        None,
        Some("."),
        Some("XP_00422"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Plasmodium falciparum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5833.MAL13P1.1";
/// let this_library_node_name2 = "5833.PFL2665c";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_plasmodium_falciparum_node_name(this_library_node_name1));
/// assert!(is_valid_string_plasmodium_falciparum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_plasmodium_falciparum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_plasmodium_falciparum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5833"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Plasmodium knowlesi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5850.PKH_010010";
/// let this_library_node_name2 = "5850.PKH_147000";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_plasmodium_knowlesi_node_name(this_library_node_name1));
/// assert!(is_valid_string_plasmodium_knowlesi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_plasmodium_knowlesi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_plasmodium_knowlesi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5850"]),
        None,
        Some("."),
        Some("PKH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Plasmodium vivax nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5855.PVX_000000";
/// let this_library_node_name2 = "5855.PVX_124725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_plasmodium_vivax_node_name(this_library_node_name1));
/// assert!(is_valid_string_plasmodium_vivax_node_name(this_library_node_name2));
/// assert!(!is_valid_string_plasmodium_vivax_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_plasmodium_vivax_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5855"]),
        None,
        Some("."),
        Some("PVX_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Plasmodium vinckei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5860.XP_008621913.1";
/// let this_library_node_name2 = "5860.XP_008626866.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_plasmodium_vinckei_node_name(this_library_node_name1));
/// assert!(is_valid_string_plasmodium_vinckei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_plasmodium_vinckei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_plasmodium_vinckei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5860"]),
        None,
        Some("."),
        Some("XP_00862"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Babesia bovis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5865.XP_001608616.1";
/// let this_library_node_name2 = "5865.XP_001612318.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_babesia_bovis_node_name(this_library_node_name1));
/// assert!(is_valid_string_babesia_bovis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_babesia_bovis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_babesia_bovis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5865"]),
        None,
        Some("."),
        Some("XP_0016"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Babesia equi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5872.XP_004828571.1";
/// let this_library_node_name2 = "5872.XP_004833899.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_babesia_equi_node_name(this_library_node_name1));
/// assert!(is_valid_string_babesia_equi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_babesia_equi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_babesia_equi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5872"]),
        None,
        Some("."),
        Some("XP_0048"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Theileria annulata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5874.XP_951758.1";
/// let this_library_node_name2 = "5874.XP_955552.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_theileria_annulata_node_name(this_library_node_name1));
/// assert!(is_valid_string_theileria_annulata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_theileria_annulata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_theileria_annulata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5874"]),
        None,
        Some("."),
        Some("XP_95"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Theileria parva nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5875.XP_762670.1";
/// let this_library_node_name2 = "5875.XP_766748.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_theileria_parva_node_name(this_library_node_name1));
/// assert!(is_valid_string_theileria_parva_node_name(this_library_node_name2));
/// assert!(!is_valid_string_theileria_parva_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_theileria_parva_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5875"]),
        None,
        Some("."),
        Some("XP_76"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paramecium tetraurelia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5888.CAK55566";
/// let this_library_node_name2 = "5888.CAK95231";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paramecium_tetraurelia_node_name(this_library_node_name1));
/// assert!(is_valid_string_paramecium_tetraurelia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paramecium_tetraurelia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paramecium_tetraurelia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5888"]),
        None,
        Some("."),
        Some("CAK"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tetrahymena thermophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5911.EAR80512";
/// let this_library_node_name2 = "5911.EEH11763";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tetrahymena_thermophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_tetrahymena_thermophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tetrahymena_thermophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tetrahymena_thermophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5911"]),
        None,
        Some("."),
        Some("E"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ichthyophthirius multifiliis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5932.XP_004023746.1";
/// let this_library_node_name2 = "5932.XP_004065518.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ichthyophthirius_multifiliis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ichthyophthirius_multifiliis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ichthyophthirius_multifiliis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ichthyophthirius_multifiliis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5932"]),
        None,
        Some("."),
        Some("XP_0040"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Exophiala dermatitidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "5970.XP_009152235.1";
/// let this_library_node_name2 = "5970.XP_009161796.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_exophiala_dermatitidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_exophiala_dermatitidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_exophiala_dermatitidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_exophiala_dermatitidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["5970"]),
        None,
        Some("."),
        Some("XP_0091"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hydra vulgaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "6087.XP_002153777.2";
/// let this_library_node_name2 = "6087.XP_004213387.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hydra_vulgaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_hydra_vulgaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hydra_vulgaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hydra_vulgaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["6087"]),
        None,
        Some("."),
        Some("XP_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Schistosoma mansoni nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "6183.Smp_000020.1";
/// let this_library_node_name2 = "6183.Smp_900110.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_schistosoma_mansoni_node_name(this_library_node_name1));
/// assert!(is_valid_string_schistosoma_mansoni_node_name(this_library_node_name2));
/// assert!(!is_valid_string_schistosoma_mansoni_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_schistosoma_mansoni_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["6183"]),
        None,
        Some("."),
        Some("Smp_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Echinococcus multilocularis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "6211.A0A068XSU6";
/// let this_library_node_name2 = "6211.U6I8U8";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_echinococcus_multilocularis_node_name(this_library_node_name1));
/// assert!(is_valid_string_echinococcus_multilocularis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_echinococcus_multilocularis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_echinococcus_multilocularis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["6211"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caenorhabditis briggsae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "6238.CBG00001";
/// let this_library_node_name2 = "6238.CBG29121";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caenorhabditis_briggsae_node_name(this_library_node_name1));
/// assert!(is_valid_string_caenorhabditis_briggsae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caenorhabditis_briggsae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caenorhabditis_briggsae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["6238"]),
        None,
        Some("."),
        Some("CBG"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caenorhabditis elegans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "6239.2L52.1";
/// let this_library_node_name2 = "6239.cTel55X.1b";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caenorhabditis_elegans_node_name(this_library_node_name1));
/// assert!(is_valid_string_caenorhabditis_elegans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caenorhabditis_elegans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caenorhabditis_elegans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["6239"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bursaphelenchus xylophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "6326.BUX.c00008.1";
/// let this_library_node_name2 = "6326.BUX.s01662.99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bursaphelenchus_xylophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bursaphelenchus_xylophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bursaphelenchus_xylophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bursaphelenchus_xylophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["6326"]),
        None,
        Some("."),
        Some("BUX"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichinella spiralis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "6334.EFV46182";
/// let this_library_node_name2 = "6334.EFV62561";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichinella_spiralis_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichinella_spiralis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichinella_spiralis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichinella_spiralis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["6334"]),
        None,
        Some("."),
        Some("EFV"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helobdella robusta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "6412.HelroP100002";
/// let this_library_node_name2 = "6412.HelroP99990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helobdella_robusta_node_name(this_library_node_name1));
/// assert!(is_valid_string_helobdella_robusta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helobdella_robusta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helobdella_robusta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["6412"]),
        None,
        Some("."),
        Some("HelroP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aplysia californica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "6500.NP_001191392.1";
/// let this_library_node_name2 = "6500.XP_005113625.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aplysia_californica_node_name(this_library_node_name1));
/// assert!(is_valid_string_aplysia_californica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aplysia_californica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aplysia_californica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["6500"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Daphnia pulex nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "6669.EFX59851";
/// let this_library_node_name2 = "6669.EFX90461";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_daphnia_pulex_node_name(this_library_node_name1));
/// assert!(is_valid_string_daphnia_pulex_node_name(this_library_node_name2));
/// assert!(!is_valid_string_daphnia_pulex_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_daphnia_pulex_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["6669"]),
        None,
        Some("."),
        Some("EFX"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acyrthosiphon pisum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7029.ACYPI000001-PA";
/// let this_library_node_name2 = "7029.ACYPI56898-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acyrthosiphon_pisum_node_name(this_library_node_name1));
/// assert!(is_valid_string_acyrthosiphon_pisum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acyrthosiphon_pisum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acyrthosiphon_pisum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7029"]),
        None,
        Some("."),
        Some("ACYPI"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tribolium castaneum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7070.TC000001-PA";
/// let this_library_node_name2 = "7070.TC030878-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tribolium_castaneum_node_name(this_library_node_name1));
/// assert!(is_valid_string_tribolium_castaneum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tribolium_castaneum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tribolium_castaneum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7070"]),
        None,
        Some("."),
        Some("TC0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bombyx mori nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7091.BGIBMGA000001-TA";
/// let this_library_node_name2 = "7091.BGIBMGA014623-TA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bombyx_mori_node_name(this_library_node_name1));
/// assert!(is_valid_string_bombyx_mori_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bombyx_mori_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bombyx_mori_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7091"]),
        None,
        Some("."),
        Some("BGIBMGA0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aedes aegypti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7159.AAEL000001-PA";
/// let this_library_node_name2 = "7159.AAEL900252-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aedes_aegypti_node_name(this_library_node_name1));
/// assert!(is_valid_string_aedes_aegypti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aedes_aegypti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aedes_aegypti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7159"]),
        None,
        Some("."),
        Some("AAEL"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anopheles gambiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7165.AGAP000002-PA";
/// let this_library_node_name2 = "7165.AGAP028429-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anopheles_gambiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_anopheles_gambiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anopheles_gambiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anopheles_gambiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7165"]),
        None,
        Some("."),
        Some("AGAP0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Culex quinquefasciatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7176.CPIJ000001-PA";
/// let this_library_node_name2 = "7176.CPIJ20332-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_culex_quinquefasciatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_culex_quinquefasciatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_culex_quinquefasciatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_culex_quinquefasciatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7176"]),
        None,
        Some("."),
        Some("CPIJ"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Loa loa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7209.EFO12200.1";
/// let this_library_node_name2 = "7209.EJD76796.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_loa_loa_node_name(this_library_node_name1));
/// assert!(is_valid_string_loa_loa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_loa_loa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_loa_loa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7209"]),
        None,
        Some("."),
        Some("E"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ceratitis capitata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7213.XP_004517316.1";
/// let this_library_node_name2 = "7213.XP_004537976.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ceratitis_capitata_node_name(this_library_node_name1));
/// assert!(is_valid_string_ceratitis_capitata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ceratitis_capitata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ceratitis_capitata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7213"]),
        None,
        Some("."),
        Some("XP_0045"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Drosophila ananassae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7217.FBpp0113192";
/// let this_library_node_name2 = "7217.FBpp0288583";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_drosophila_ananassae_node_name(this_library_node_name1));
/// assert!(is_valid_string_drosophila_ananassae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_drosophila_ananassae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_drosophila_ananassae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7217"]),
        None,
        Some("."),
        Some("FBpp0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Drosophila erecta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7220.FBpp0128581";
/// let this_library_node_name2 = "7220.FBpp0288591";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_drosophila_erecta_node_name(this_library_node_name1));
/// assert!(is_valid_string_drosophila_erecta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_drosophila_erecta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_drosophila_erecta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7220"]),
        None,
        Some("."),
        Some("FBpp0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Drosophila grimshawi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7222.FBpp0143946";
/// let this_library_node_name2 = "7222.FBpp0288599";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_drosophila_grimshawi_node_name(this_library_node_name1));
/// assert!(is_valid_string_drosophila_grimshawi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_drosophila_grimshawi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_drosophila_grimshawi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7222"]),
        None,
        Some("."),
        Some("FBpp0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Drosophila melanogaster nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7227.FBpp0070001";
/// let this_library_node_name2 = "7227.FBpp0306233";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_drosophila_melanogaster_node_name(this_library_node_name1));
/// assert!(is_valid_string_drosophila_melanogaster_node_name(this_library_node_name2));
/// assert!(!is_valid_string_drosophila_melanogaster_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_drosophila_melanogaster_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7227"]),
        None,
        Some("."),
        Some("FBpp0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Drosophila mojavensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7230.FBpp0159257";
/// let this_library_node_name2 = "7230.FBpp0288601";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_drosophila_mojavensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_drosophila_mojavensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_drosophila_mojavensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_drosophila_mojavensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7230"]),
        None,
        Some("."),
        Some("FBpp0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Drosophila persimilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7234.FBpp0174151";
/// let this_library_node_name2 = "7234.FBpp0288609";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_drosophila_persimilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_drosophila_persimilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_drosophila_persimilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_drosophila_persimilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7234"]),
        None,
        Some("."),
        Some("FBpp0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Drosophila pseudoobscura nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7237.FBpp0271968";
/// let this_library_node_name2 = "7237.FBpp0308212";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_drosophila_pseudoobscura_node_name(this_library_node_name1));
/// assert!(is_valid_string_drosophila_pseudoobscura_node_name(this_library_node_name2));
/// assert!(!is_valid_string_drosophila_pseudoobscura_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_drosophila_pseudoobscura_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7237"]),
        None,
        Some("."),
        Some("FBpp0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Drosophila virilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7244.FBpp0224461";
/// let this_library_node_name2 = "7244.FBpp0239140";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_drosophila_virilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_drosophila_virilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_drosophila_virilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_drosophila_virilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7244"]),
        None,
        Some("."),
        Some("FBpp02"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Drosophila yakuba nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7245.FBpp0255048";
/// let this_library_node_name2 = "7245.FBpp0288633";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_drosophila_yakuba_node_name(this_library_node_name1));
/// assert!(is_valid_string_drosophila_yakuba_node_name(this_library_node_name2));
/// assert!(!is_valid_string_drosophila_yakuba_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_drosophila_yakuba_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7245"]),
        None,
        Some("."),
        Some("FBpp02"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Drosophila willistoni nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7260.FBpp0239194";
/// let this_library_node_name2 = "7260.FBpp0288623";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_drosophila_willistoni_node_name(this_library_node_name1));
/// assert!(is_valid_string_drosophila_willistoni_node_name(this_library_node_name2));
/// assert!(!is_valid_string_drosophila_willistoni_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_drosophila_willistoni_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7260"]),
        None,
        Some("."),
        Some("FBpp02"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Musca domestica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7370.XP_005174763.1";
/// let this_library_node_name2 = "7370.XP_005192270.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_musca_domestica_node_name(this_library_node_name1));
/// assert!(is_valid_string_musca_domestica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_musca_domestica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_musca_domestica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7370"]),
        None,
        Some("."),
        Some("XP_0051"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nasonia vitripennis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7425.NV10002-PA";
/// let this_library_node_name2 = "7425.NV31870-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nasonia_vitripennis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nasonia_vitripennis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nasonia_vitripennis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nasonia_vitripennis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7425"]),
        None,
        Some("."),
        Some("NV"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Apis mellifera nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7460.GB40001-PA";
/// let this_library_node_name2 = "7460.GB56038-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_apis_mellifera_node_name(this_library_node_name1));
/// assert!(is_valid_string_apis_mellifera_node_name(this_library_node_name2));
/// assert!(!is_valid_string_apis_mellifera_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_apis_mellifera_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7460"]),
        None,
        Some("."),
        Some("GB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Strongylocentrotus purpuratus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7668.SPU_000001-tr";
/// let this_library_node_name2 = "7668.SPU_030236-tr";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_strongylocentrotus_purpuratus_node_name(this_library_node_name1));
/// assert!(is_valid_string_strongylocentrotus_purpuratus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_strongylocentrotus_purpuratus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_strongylocentrotus_purpuratus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7668"]),
        None,
        Some("."),
        Some("SPU_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ciona intestinalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7719.NP_001007565.1";
/// let this_library_node_name2 = "7719.XP_009862527.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ciona_intestinalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ciona_intestinalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ciona_intestinalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ciona_intestinalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7719"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Branchiostoma floridae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7739.XP_002585489.1";
/// let this_library_node_name2 = "7739.XP_002614114.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_branchiostoma_floridae_node_name(this_library_node_name1));
/// assert!(is_valid_string_branchiostoma_floridae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_branchiostoma_floridae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_branchiostoma_floridae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7739"]),
        None,
        Some("."),
        Some("XP_002"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Latimeria chalumnae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7897.ENSLACP00000000001";
/// let this_library_node_name2 = "7897.ENSLACP00000023659";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_latimeria_chalumnae_node_name(this_library_node_name1));
/// assert!(is_valid_string_latimeria_chalumnae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_latimeria_chalumnae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_latimeria_chalumnae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7897"]),
        None,
        Some("."),
        Some("ENSLACP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lepisosteus oculatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7918.ENSLOCP00000000001";
/// let this_library_node_name2 = "7918.ENSLOCP00000022483";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lepisosteus_oculatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lepisosteus_oculatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lepisosteus_oculatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lepisosteus_oculatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7918"]),
        None,
        Some("."),
        Some("ENSLOCP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Danio rerio nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7955.ENSDARP00000000004";
/// let this_library_node_name2 = "7955.ENSDARP00000129874";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_danio_rerio_node_name(this_library_node_name1));
/// assert!(is_valid_string_danio_rerio_node_name(this_library_node_name2));
/// assert!(!is_valid_string_danio_rerio_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_danio_rerio_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7955"]),
        None,
        Some("."),
        Some("ENSDARP00000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Astyanax mexicanus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "7994.ENSAMXP00000000001";
/// let this_library_node_name2 = "7994.ENSAMXP00000027211";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_astyanax_mexicanus_node_name(this_library_node_name1));
/// assert!(is_valid_string_astyanax_mexicanus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_astyanax_mexicanus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_astyanax_mexicanus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["7994"]),
        None,
        Some("."),
        Some("ENSAMXP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Esox lucius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8010.XP_010861956.1";
/// let this_library_node_name2 = "8010.XP_010904530.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_esox_lucius_node_name(this_library_node_name1));
/// assert!(is_valid_string_esox_lucius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_esox_lucius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_esox_lucius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8010"]),
        None,
        Some("."),
        Some("XP_010"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gadus morhua nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8049.ENSGMOP00000000001";
/// let this_library_node_name2 = "8049.ENSGMOP00000022100";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gadus_morhua_node_name(this_library_node_name1));
/// assert!(is_valid_string_gadus_morhua_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gadus_morhua_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gadus_morhua_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8049"]),
        None,
        Some("."),
        Some("ENSGMOP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Poecilia reticulata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8081.XP_008394332.1";
/// let this_library_node_name2 = "8081.XP_008436959.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_poecilia_reticulata_node_name(this_library_node_name1));
/// assert!(is_valid_string_poecilia_reticulata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_poecilia_reticulata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_poecilia_reticulata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8081"]),
        None,
        Some("."),
        Some("XP_008"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xiphophorus maculatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8083.ENSXMAP00000000002";
/// let this_library_node_name2 = "8083.ENSXMAP00000020468";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xiphophorus_maculatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_xiphophorus_maculatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xiphophorus_maculatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xiphophorus_maculatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8083"]),
        None,
        Some("."),
        Some("ENSXMAP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryzias latipes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8090.ENSORLP00000000001";
/// let this_library_node_name2 = "8090.ENSORLP00000025893";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryzias_latipes_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryzias_latipes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryzias_latipes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryzias_latipes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8090"]),
        None,
        Some("."),
        Some("ENSORLP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oreochromis niloticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8128.ENSONIP00000000001";
/// let this_library_node_name2 = "8128.ENSONIP00000026764";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oreochromis_niloticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_oreochromis_niloticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oreochromis_niloticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oreochromis_niloticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8128"]),
        None,
        Some("."),
        Some("ENSONIP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haplochromis burtoni nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8153.XP_005912068.1";
/// let this_library_node_name2 = "8153.XP_005953752.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haplochromis_burtoni_node_name(this_library_node_name1));
/// assert!(is_valid_string_haplochromis_burtoni_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haplochromis_burtoni_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haplochromis_burtoni_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8153"]),
        None,
        Some("."),
        Some("XP_0059"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xenopus tropicalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8364.ENSXETP00000000002";
/// let this_library_node_name2 = "8364.ENSXETP00000064144";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xenopus_tropicalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_xenopus_tropicalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xenopus_tropicalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xenopus_tropicalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8364"]),
        None,
        Some("."),
        Some("ENSXETP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chelonia mydas nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8469.XP_007052626.1";
/// let this_library_node_name2 = "8469.XP_007072873.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chelonia_mydas_node_name(this_library_node_name1));
/// assert!(is_valid_string_chelonia_mydas_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chelonia_mydas_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chelonia_mydas_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8469"]),
        None,
        Some("."),
        Some("XP_0070"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chrysemys picta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8479.NP_001269172.1";
/// let this_library_node_name2 = "8479.XP_008178122.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chrysemys_picta_node_name(this_library_node_name1));
/// assert!(is_valid_string_chrysemys_picta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chrysemys_picta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chrysemys_picta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8479"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alligator mississippiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8496.XP_006257804.1";
/// let this_library_node_name2 = "8496.XP_006279029.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alligator_mississippiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alligator_mississippiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alligator_mississippiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alligator_mississippiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8496"]),
        None,
        Some("."),
        Some("XP_0062"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Columba livia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "8932.XP_005498021.1";
/// let this_library_node_name2 = "8932.XP_005516202.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_columba_livia_node_name(this_library_node_name1));
/// assert!(is_valid_string_columba_livia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_columba_livia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_columba_livia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["8932"]),
        None,
        Some("."),
        Some("XP_005"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gallus gallus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9031.ENSGALP00000000002";
/// let this_library_node_name2 = "9031.ENSGALP00000043477";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gallus_gallus_node_name(this_library_node_name1));
/// assert!(is_valid_string_gallus_gallus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gallus_gallus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gallus_gallus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9031"]),
        None,
        Some("."),
        Some("ENSGALP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ornithorhynchus anatinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9258.ENSOANP00000000222";
/// let this_library_node_name2 = "9258.ENSOANP00000033275";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ornithorhynchus_anatinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ornithorhynchus_anatinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ornithorhynchus_anatinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ornithorhynchus_anatinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9258"]),
        None,
        Some("."),
        Some("ENSOANP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sarcophilus harrisii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9305.ENSSHAP00000000001";
/// let this_library_node_name2 = "9305.ENSSHAP00000022404";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sarcophilus_harrisii_node_name(this_library_node_name1));
/// assert!(is_valid_string_sarcophilus_harrisii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sarcophilus_harrisii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sarcophilus_harrisii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9305"]),
        None,
        Some("."),
        Some("ENSSHAP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Macropus eugenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9315.ENSMEUP00000000001";
/// let this_library_node_name2 = "9315.ENSMEUP00000015342";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_macropus_eugenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_macropus_eugenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_macropus_eugenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_macropus_eugenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9315"]),
        None,
        Some("."),
        Some("ENSMEUP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dasypus novemcinctus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9361.ENSDNOP00000000003";
/// let this_library_node_name2 = "9361.ENSDNOP00000035279";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dasypus_novemcinctus_node_name(this_library_node_name1));
/// assert!(is_valid_string_dasypus_novemcinctus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dasypus_novemcinctus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dasypus_novemcinctus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9361"]),
        None,
        Some("."),
        Some("ENSDNOP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erinaceus europaeus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9365.XP_007515831.1";
/// let this_library_node_name2 = "9365.XP_007540121.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erinaceus_europaeus_node_name(this_library_node_name1));
/// assert!(is_valid_string_erinaceus_europaeus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erinaceus_europaeus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erinaceus_europaeus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9365"]),
        None,
        Some("."),
        Some("XP_0075"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Echinops telfairi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9371.XP_004696068.1";
/// let this_library_node_name2 = "9371.XP_004718279.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_echinops_telfairi_node_name(this_library_node_name1));
/// assert!(is_valid_string_echinops_telfairi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_echinops_telfairi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_echinops_telfairi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9371"]),
        None,
        Some("."),
        Some("XP_004"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pteropus alecto nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9402.XP_006903879.1";
/// let this_library_node_name2 = "9402.XP_006927206.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pteropus_alecto_node_name(this_library_node_name1));
/// assert!(is_valid_string_pteropus_alecto_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pteropus_alecto_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pteropus_alecto_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9402"]),
        None,
        Some("."),
        Some("XP_0069"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tarsius syrichta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9478.XP_008046011.1";
/// let this_library_node_name2 = "9478.XP_008073017.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tarsius_syrichta_node_name(this_library_node_name1));
/// assert!(is_valid_string_tarsius_syrichta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tarsius_syrichta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tarsius_syrichta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9478"]),
        None,
        Some("."),
        Some("XP_0080"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Callithrix jacchus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9483.ENSCJAP00000000001";
/// let this_library_node_name2 = "9483.ENSCJAP00000052497";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_callithrix_jacchus_node_name(this_library_node_name1));
/// assert!(is_valid_string_callithrix_jacchus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_callithrix_jacchus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_callithrix_jacchus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9483"]),
        None,
        Some("."),
        Some("ENSCJAP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Macaca fascicularis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9541.XP_005539567.1";
/// let this_library_node_name2 = "9541.XP_005596142.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_macaca_fascicularis_node_name(this_library_node_name1));
/// assert!(is_valid_string_macaca_fascicularis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_macaca_fascicularis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_macaca_fascicularis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9541"]),
        None,
        Some("."),
        Some("XP_0055"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Macaca mulatta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9544.ENSMMUP00000000001";
/// let this_library_node_name2 = "9544.ENSMMUP00000041394";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_macaca_mulatta_node_name(this_library_node_name1));
/// assert!(is_valid_string_macaca_mulatta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_macaca_mulatta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_macaca_mulatta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9544"]),
        None,
        Some("."),
        Some("ENSMMUP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Papio anubis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9555.ENSPANP00000000001";
/// let this_library_node_name2 = "9555.ENSPANP00000020976";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_papio_anubis_node_name(this_library_node_name1));
/// assert!(is_valid_string_papio_anubis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_papio_anubis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_papio_anubis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9555"]),
        None,
        Some("."),
        Some("ENSPANP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gorilla gorilla nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9593.ENSGGOP00000000002";
/// let this_library_node_name2 = "9593.ENSGGOP00000028766";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gorilla_gorilla_node_name(this_library_node_name1));
/// assert!(is_valid_string_gorilla_gorilla_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gorilla_gorilla_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gorilla_gorilla_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9593"]),
        None,
        Some("."),
        Some("ENSGGOP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pan paniscus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9597.NP_001266105.1";
/// let this_library_node_name2 = "9597.XP_008977055.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pan_paniscus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pan_paniscus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pan_paniscus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pan_paniscus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9597"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pan troglodytes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9598.ENSPTRP00000000011";
/// let this_library_node_name2 = "9598.ENSPTRP00000061410";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pan_troglodytes_node_name(this_library_node_name1));
/// assert!(is_valid_string_pan_troglodytes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pan_troglodytes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pan_troglodytes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9598"]),
        None,
        Some("."),
        Some("ENSPTRP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pongo abelii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9601.ENSPPYP00000000001";
/// let this_library_node_name2 = "9601.ENSPPYP00000024779";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pongo_abelii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pongo_abelii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pongo_abelii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pongo_abelii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9601"]),
        None,
        Some("."),
        Some("ENSPPYP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Homo sapiens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9606.ENSP00000000233";
/// let this_library_node_name2 = "9606.ENSP00000485678";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_homo_sapiens_node_name(this_library_node_name1));
/// assert!(is_valid_string_homo_sapiens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_homo_sapiens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_homo_sapiens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9606"]),
        None,
        Some("."),
        Some("ENSP00000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Canis lupus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9612.ENSCAFP00000000001";
/// let this_library_node_name2 = "9612.ENSCAFP00000043230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_canis_lupus_node_name(this_library_node_name1));
/// assert!(is_valid_string_canis_lupus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_canis_lupus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_canis_lupus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9612"]),
        None,
        Some("."),
        Some("ENSCAFP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ailuropoda melanoleuca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9646.ENSAMEP00000000001";
/// let this_library_node_name2 = "9646.ENSAMEP00000021365";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ailuropoda_melanoleuca_node_name(this_library_node_name1));
/// assert!(is_valid_string_ailuropoda_melanoleuca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ailuropoda_melanoleuca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ailuropoda_melanoleuca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9646"]),
        None,
        Some("."),
        Some("ENSAMEP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mustela putorius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9668.ENSMPUP00000000002";
/// let this_library_node_name2 = "9668.ENSMPUP00000020063";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mustela_putorius_node_name(this_library_node_name1));
/// assert!(is_valid_string_mustela_putorius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mustela_putorius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mustela_putorius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9668"]),
        None,
        Some("."),
        Some("ENSMPUP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Felis catus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9685.ENSFCAP00000000001";
/// let this_library_node_name2 = "9685.ENSFCAP00000025722";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_felis_catus_node_name(this_library_node_name1));
/// assert!(is_valid_string_felis_catus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_felis_catus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_felis_catus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9685"]),
        None,
        Some("."),
        Some("ENSFCAP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Panthera tigris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9694.XP_007072874.1";
/// let this_library_node_name2 = "9694.XP_007099500.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_panthera_tigris_node_name(this_library_node_name1));
/// assert!(is_valid_string_panthera_tigris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_panthera_tigris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_panthera_tigris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9694"]),
        None,
        Some("."),
        Some("XP_0070"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Odobenus rosmarus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9707.XP_004391520.1";
/// let this_library_node_name2 = "9707.XP_004417921.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_odobenus_rosmarus_node_name(this_library_node_name1));
/// assert!(is_valid_string_odobenus_rosmarus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_odobenus_rosmarus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_odobenus_rosmarus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9707"]),
        None,
        Some("."),
        Some("XP_004"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptonychotes weddellii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9713.XP_006726925.1";
/// let this_library_node_name2 = "9713.XP_006752629.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptonychotes_weddellii_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptonychotes_weddellii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptonychotes_weddellii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptonychotes_weddellii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9713"]),
        None,
        Some("."),
        Some("XP_0067"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Orcinus orca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9733.XP_004262143.1";
/// let this_library_node_name2 = "9733.XP_004287056.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_orcinus_orca_node_name(this_library_node_name1));
/// assert!(is_valid_string_orcinus_orca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_orcinus_orca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_orcinus_orca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9733"]),
        None,
        Some("."),
        Some("XP_0042"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tursiops truncatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9739.XP_004310291.1";
/// let this_library_node_name2 = "9739.XP_004332790.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tursiops_truncatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_tursiops_truncatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tursiops_truncatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tursiops_truncatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9739"]),
        None,
        Some("."),
        Some("XP_0043"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Balaenoptera acutorostrata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9767.XP_007163994.1";
/// let this_library_node_name2 = "9767.XP_007198801.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_balaenoptera_acutorostrata_node_name(this_library_node_name1));
/// assert!(is_valid_string_balaenoptera_acutorostrata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_balaenoptera_acutorostrata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_balaenoptera_acutorostrata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9767"]),
        None,
        Some("."),
        Some("XP_0071"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichechus manatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9778.XP_004368333.1";
/// let this_library_node_name2 = "9778.XP_004391519.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichechus_manatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichechus_manatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichechus_manatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichechus_manatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9778"]),
        None,
        Some("."),
        Some("XP_0043"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Loxodonta africana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9785.ENSLAFP00000000001";
/// let this_library_node_name2 = "9785.ENSLAFP00000029503";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_loxodonta_africana_node_name(this_library_node_name1));
/// assert!(is_valid_string_loxodonta_africana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_loxodonta_africana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_loxodonta_africana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9785"]),
        None,
        Some("."),
        Some("ENSLAFP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Orycteropus afer nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9818.XP_007932690.1";
/// let this_library_node_name2 = "9818.XP_007958218.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_orycteropus_afer_node_name(this_library_node_name1));
/// assert!(is_valid_string_orycteropus_afer_node_name(this_library_node_name2));
/// assert!(!is_valid_string_orycteropus_afer_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_orycteropus_afer_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9818"]),
        None,
        Some("."),
        Some("XP_0079"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sus scrofa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9823.ENSSSCP00000000001";
/// let this_library_node_name2 = "9823.ENSSSCP00000031116";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sus_scrofa_node_name(this_library_node_name1));
/// assert!(is_valid_string_sus_scrofa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sus_scrofa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sus_scrofa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9823"]),
        None,
        Some("."),
        Some("ENSSSCP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bos taurus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9913.ENSBTAP00000000005";
/// let this_library_node_name2 = "9913.ENSBTAP00000056646";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bos_taurus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bos_taurus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bos_taurus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bos_taurus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9913"]),
        None,
        Some("."),
        Some("ENSBTAP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ovis aries nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9940.ENSOARP00000000001";
/// let this_library_node_name2 = "9940.ENSOARP00000022824";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ovis_aries_node_name(this_library_node_name1));
/// assert!(is_valid_string_ovis_aries_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ovis_aries_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ovis_aries_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9940"]),
        None,
        Some("."),
        Some("ENSOARP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ochotona princeps nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9978.XP_004576775.1";
/// let this_library_node_name2 = "9978.XP_004600150.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ochotona_princeps_node_name(this_library_node_name1));
/// assert!(is_valid_string_ochotona_princeps_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ochotona_princeps_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ochotona_princeps_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9978"]),
        None,
        Some("."),
        Some("XP_004"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryctolagus cuniculus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "9986.ENSOCUP00000000001";
/// let this_library_node_name2 = "9986.ENSOCUP00000027218";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryctolagus_cuniculus_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryctolagus_cuniculus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryctolagus_cuniculus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryctolagus_cuniculus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["9986"]),
        None,
        Some("."),
        Some("ENSOCUP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cricetulus griseus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "10029.NP_001230905.1";
/// let this_library_node_name2 = "10029.XP_007653442.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cricetulus_griseus_node_name(this_library_node_name1));
/// assert!(is_valid_string_cricetulus_griseus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cricetulus_griseus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cricetulus_griseus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["10029"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesocricetus auratus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "10036.XP_005063187.1";
/// let this_library_node_name2 = "10036.XP_005139446.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesocricetus_auratus_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesocricetus_auratus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesocricetus_auratus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesocricetus_auratus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["10036"]),
        None,
        Some("."),
        Some("XP_005"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peromyscus maniculatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "10042.XP_006970026.1";
/// let this_library_node_name2 = "10042.XP_006999186.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peromyscus_maniculatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_peromyscus_maniculatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peromyscus_maniculatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peromyscus_maniculatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["10042"]),
        None,
        Some("."),
        Some("XP_0069"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mus musculus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "10090.ENSMUSP00000000001";
/// let this_library_node_name2 = "10090.ENSMUSP00000141183";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mus_musculus_node_name(this_library_node_name1));
/// assert!(is_valid_string_mus_musculus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mus_musculus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mus_musculus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["10090"]),
        None,
        Some("."),
        Some("ENSMUSP00000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rattus norvegicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "10116.ENSRNOP00000000006";
/// let this_library_node_name2 = "10116.ENSRNOP00000068526";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rattus_norvegicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rattus_norvegicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rattus_norvegicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rattus_norvegicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["10116"]),
        None,
        Some("."),
        Some("ENSRNOP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cavia porcellus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "10141.ENSCPOP00000000003";
/// let this_library_node_name2 = "10141.ENSCPOP00000021257";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cavia_porcellus_node_name(this_library_node_name1));
/// assert!(is_valid_string_cavia_porcellus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cavia_porcellus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cavia_porcellus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["10141"]),
        None,
        Some("."),
        Some("ENSCPOP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Octodon degus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "10160.XP_004622924.1";
/// let this_library_node_name2 = "10160.XP_004649171.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_octodon_degus_node_name(this_library_node_name1));
/// assert!(is_valid_string_octodon_degus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_octodon_degus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_octodon_degus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["10160"]),
        None,
        Some("."),
        Some("XP_0046"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Heterocephalus glaber nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "10181.NP_001254519.1";
/// let this_library_node_name2 = "10181.XP_004921466.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_heterocephalus_glaber_node_name(this_library_node_name1));
/// assert!(is_valid_string_heterocephalus_glaber_node_name(this_library_node_name2));
/// assert!(!is_valid_string_heterocephalus_glaber_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_heterocephalus_glaber_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["10181"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccoglossus kowalevskii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "10224.NP_001158358.1";
/// let this_library_node_name2 = "10224.XP_006826139.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccoglossus_kowalevskii_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccoglossus_kowalevskii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccoglossus_kowalevskii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccoglossus_kowalevskii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["10224"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichoplax adhaerens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "10228.TriadP1002";
/// let this_library_node_name2 = "10228.TriadP9980";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichoplax_adhaerens_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichoplax_adhaerens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichoplax_adhaerens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichoplax_adhaerens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["10228"]),
        None,
        Some("."),
        Some("TriadP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atta cephalotes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "12957.ACEP10001-PA";
/// let this_library_node_name2 = "12957.ACEP28062-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atta_cephalotes_node_name(this_library_node_name1));
/// assert!(is_valid_string_atta_cephalotes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atta_cephalotes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atta_cephalotes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["12957"]),
        None,
        Some("."),
        Some("ACEP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dactylococcopsis salina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "13035.Dacsa_0001";
/// let this_library_node_name2 = "13035.Dacsa_3684";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dactylococcopsis_salina_node_name(this_library_node_name1));
/// assert!(is_valid_string_dactylococcopsis_salina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dactylococcopsis_salina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dactylococcopsis_salina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["13035"]),
        None,
        Some("."),
        Some("Dacsa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Danaus plexippus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "13037.EHJ63042";
/// let this_library_node_name2 = "13037.EHJ79295";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_danaus_plexippus_node_name(this_library_node_name1));
/// assert!(is_valid_string_danaus_plexippus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_danaus_plexippus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_danaus_plexippus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["13037"]),
        None,
        Some("."),
        Some("EHJ"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodnius prolixus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "13249.RPRC000001-PA";
/// let this_library_node_name2 = "13249.RPRC015472-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodnius_prolixus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodnius_prolixus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodnius_prolixus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodnius_prolixus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["13249"]),
        None,
        Some("."),
        Some("RPRC0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amborella trichopoda nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "13333.ERM93378";
/// let this_library_node_name2 = "13333.ERN20691";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amborella_trichopoda_node_name(this_library_node_name1));
/// assert!(is_valid_string_amborella_trichopoda_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amborella_trichopoda_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amborella_trichopoda_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["13333"]),
        None,
        Some("."),
        Some("ER"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobotrys oligospora nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "13349.G1WXJ0";
/// let this_library_node_name2 = "13349.G1XVB8";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobotrys_oligospora_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobotrys_oligospora_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobotrys_oligospora_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobotrys_oligospora_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["13349"]),
        None,
        Some("."),
        Some("G1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Monodelphis domestica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "13616.ENSMODP00000000001";
/// let this_library_node_name2 = "13616.ENSMODP00000041350";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_monodelphis_domestica_node_name(this_library_node_name1));
/// assert!(is_valid_string_monodelphis_domestica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_monodelphis_domestica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_monodelphis_domestica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["13616"]),
        None,
        Some("."),
        Some("ENSMODP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parastagonospora nodorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "13684.ABU49434";
/// let this_library_node_name2 = "13684.SNOT_20187";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parastagonospora_nodorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_parastagonospora_nodorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parastagonospora_nodorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parastagonospora_nodorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["13684"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas paucimobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "13689.BV96_00001";
/// let this_library_node_name2 = "13689.BV96_04757";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_paucimobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_paucimobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_paucimobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_paucimobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["13689"]),
        None,
        Some("."),
        Some("BV96_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium yanoikuyae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "13690.CP98_00001";
/// let this_library_node_name2 = "13690.CP98_05392";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_yanoikuyae_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_yanoikuyae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_yanoikuyae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_yanoikuyae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["13690"]),
        None,
        Some("."),
        Some("CP98_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelodiscus sinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "13735.ENSPSIP00000000001";
/// let this_library_node_name2 = "13735.ENSPSIP00000020669";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelodiscus_sinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelodiscus_sinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelodiscus_sinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelodiscus_sinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["13735"]),
        None,
        Some("."),
        Some("ENSPSIP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachypodium distachyon nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "15368.BRADI0007S00200.2";
/// let this_library_node_name2 = "15368.BRADI5G27720.2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachypodium_distachyon_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachypodium_distachyon_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachypodium_distachyon_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachypodium_distachyon_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["15368"]),
        None,
        Some("."),
        Some("BRADI"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Naumovozyma castellii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "27288.XP_003672961.1";
/// let this_library_node_name2 = "27288.XP_003678552.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_naumovozyma_castellii_node_name(this_library_node_name1));
/// assert!(is_valid_string_naumovozyma_castellii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_naumovozyma_castellii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_naumovozyma_castellii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["27288"]),
        None,
        Some("."),
        Some("XP_00367"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Naumovozyma dairenensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "27289.XP_003667413.1";
/// let this_library_node_name2 = "27289.XP_003980290.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_naumovozyma_dairenensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_naumovozyma_dairenensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_naumovozyma_dairenensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_naumovozyma_dairenensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["27289"]),
        None,
        Some("."),
        Some("XP_003"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Verticillium dahliae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "27337.EGY13319";
/// let this_library_node_name2 = "27337.EGY23853";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_verticillium_dahliae_node_name(this_library_node_name1));
/// assert!(is_valid_string_verticillium_dahliae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_verticillium_dahliae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_verticillium_dahliae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["27337"]),
        None,
        Some("."),
        Some("EGY"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saimiri boliviensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "27679.NP_001265469.1";
/// let this_library_node_name2 = "27679.XP_010350799.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saimiri_boliviensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_saimiri_boliviensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saimiri_boliviensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saimiri_boliviensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["27679"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mnemiopsis leidyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "27923.AEE60334";
/// let this_library_node_name2 = "27923.ML50851a-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mnemiopsis_leidyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_mnemiopsis_leidyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mnemiopsis_leidyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mnemiopsis_leidyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["27923"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharopolyspora rectivirgula nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28042.GU90_00010";
/// let this_library_node_name2 = "28042.GU90_18935";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharopolyspora_rectivirgula_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharopolyspora_rectivirgula_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharopolyspora_rectivirgula_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharopolyspora_rectivirgula_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28042"]),
        None,
        Some("."),
        Some("GU90_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nostoc sp. PCC7524 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28072.Nos7524_0001";
/// let this_library_node_name2 = "28072.Nos7524_5691";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nostoc_sp_pcc7524_node_name(this_library_node_name1));
/// assert!(is_valid_string_nostoc_sp_pcc7524_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nostoc_sp_pcc7524_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nostoc_sp_pcc7524_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28072"]),
        None,
        Some("."),
        Some("Nos7524_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas macacae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28115.HR11_00005";
/// let this_library_node_name2 = "28115.HR11_10610";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_macacae_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_macacae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_macacae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_macacae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28115"]),
        None,
        Some("."),
        Some("HR11_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yersinia kristensenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28152.DJ57_1";
/// let this_library_node_name2 = "28152.DJ57_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yersinia_kristensenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_yersinia_kristensenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yersinia_kristensenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yersinia_kristensenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28152"]),
        None,
        Some("."),
        Some("DJ57_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photodesmus katoptron nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28176.CF66_0101";
/// let this_library_node_name2 = "28176.CF66_9089";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photodesmus_katoptron_node_name(this_library_node_name1));
/// assert!(is_valid_string_photodesmus_katoptron_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photodesmus_katoptron_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photodesmus_katoptron_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28176"]),
        None,
        Some("."),
        Some("CF66_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Colwellia psychrerythraea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28229.ND2E_0001";
/// let this_library_node_name2 = "28229.ND2E_4381";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_colwellia_psychrerythraea_node_name(this_library_node_name1));
/// assert!(is_valid_string_colwellia_psychrerythraea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_colwellia_psychrerythraea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_colwellia_psychrerythraea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28229"]),
        None,
        Some("."),
        Some("ND2E_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cobetia marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28258.KP05_00005";
/// let this_library_node_name2 = "28258.KP05_17355";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cobetia_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_cobetia_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cobetia_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cobetia_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28258"]),
        None,
        Some("."),
        Some("KP05_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anolis carolinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28377.ENSACAP00000000002";
/// let this_library_node_name2 = "28377.ENSACAP00000023485";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anolis_carolinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anolis_carolinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anolis_carolinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anolis_carolinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28377"]),
        None,
        Some("."),
        Some("ENSACAP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Herbidospora cretacea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28444.JODQ01000001_gene1877";
/// let this_library_node_name2 = "28444.JODQ01000065_gene3077";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_herbidospora_cretacea_node_name(this_library_node_name1));
/// assert!(is_valid_string_herbidospora_cretacea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_herbidospora_cretacea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_herbidospora_cretacea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28444"]),
        None,
        Some("."),
        Some("JODQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tarenaya hassleriana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28532.XP_010518657.1";
/// let this_library_node_name2 = "28532.XP_010559314.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tarenaya_hassleriana_node_name(this_library_node_name1));
/// assert!(is_valid_string_tarenaya_hassleriana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tarenaya_hassleriana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tarenaya_hassleriana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28532"]),
        None,
        Some("."),
        Some("XP_0105"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Talaromyces stipitatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28564.XP_002339861.1";
/// let this_library_node_name2 = "28564.XP_002488857.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_talaromyces_stipitatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_talaromyces_stipitatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_talaromyces_stipitatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_talaromyces_stipitatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28564"]),
        None,
        Some("."),
        Some("XP_002"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Allomyces macrogynus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28583.AMAG_00003T0";
/// let this_library_node_name2 = "28583.AlmafMp30";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_allomyces_macrogynus_node_name(this_library_node_name1));
/// assert!(is_valid_string_allomyces_macrogynus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_allomyces_macrogynus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_allomyces_macrogynus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28583"]),
        None,
        Some("."),
        Some("A"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Elephantulus edwardii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28737.XP_006878668.1";
/// let this_library_node_name2 = "28737.XP_006903878.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_elephantulus_edwardii_node_name(this_library_node_name1));
/// assert!(is_valid_string_elephantulus_edwardii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_elephantulus_edwardii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_elephantulus_edwardii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28737"]),
        None,
        Some("."),
        Some("XP_006"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kluyveromyces lactis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "28985.XP_002999344.1";
/// let this_library_node_name2 = "28985.XP_456329.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kluyveromyces_lactis_node_name(this_library_node_name1));
/// assert!(is_valid_string_kluyveromyces_lactis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kluyveromyces_lactis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kluyveromyces_lactis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["28985"]),
        None,
        Some("."),
        Some("XP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ursus maritimus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29073.XP_008681660.1";
/// let this_library_node_name2 = "29073.XP_008710528.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ursus_maritimus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ursus_maritimus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ursus_maritimus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ursus_maritimus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29073"]),
        None,
        Some("."),
        Some("XP_008"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eptesicus fuscus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29078.XP_008136555.1";
/// let this_library_node_name2 = "29078.XP_008160699.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eptesicus_fuscus_node_name(this_library_node_name1));
/// assert!(is_valid_string_eptesicus_fuscus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eptesicus_fuscus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eptesicus_fuscus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29078"]),
        None,
        Some("."),
        Some("XP_0081"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neospora caninum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29176.XP_003879538.1";
/// let this_library_node_name2 = "29176.XP_003886473.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neospora_caninum_node_name(this_library_node_name1));
/// assert!(is_valid_string_neospora_caninum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neospora_caninum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neospora_caninum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29176"]),
        None,
        Some("."),
        Some("XP_0038"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces griseoluteus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29306.JOBE01000001_gene2534";
/// let this_library_node_name2 = "29306.JOBE01000190_gene3952";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_griseoluteus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_griseoluteus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_griseoluteus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_griseoluteus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29306"]),
        None,
        Some("."),
        Some("JOBE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yersinia ruckeri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29486.NJ56_00005";
/// let this_library_node_name2 = "29486.NJ56_17820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yersinia_ruckeri_node_name(this_library_node_name1));
/// assert!(is_valid_string_yersinia_ruckeri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yersinia_ruckeri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yersinia_ruckeri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29486"]),
        None,
        Some("."),
        Some("NJ56_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio navarrensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29495.EA26_00015";
/// let this_library_node_name2 = "29495.EA26_20560";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_navarrensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_navarrensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_navarrensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_navarrensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29495"]),
        None,
        Some("."),
        Some("EA26_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natrialba asiatica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29540.C481_00005";
/// let this_library_node_name2 = "29540.C481_21286";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natrialba_asiatica_node_name(this_library_node_name1));
/// assert!(is_valid_string_natrialba_asiatica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natrialba_asiatica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natrialba_asiatica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29540"]),
        None,
        Some("."),
        Some("C481_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Janthinobacterium lividum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29581.BW37_00002";
/// let this_library_node_name2 = "29581.BW37_05534";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_janthinobacterium_lividum_node_name(this_library_node_name1));
/// assert!(is_valid_string_janthinobacterium_lividum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_janthinobacterium_lividum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_janthinobacterium_lividum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29581"]),
        None,
        Some("."),
        Some("BW37_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gossypium raimondii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29730.Gorai.001G000100.1";
/// let this_library_node_name2 = "29730.Gorai.N028200.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gossypium_raimondii_node_name(this_library_node_name1));
/// assert!(is_valid_string_gossypium_raimondii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gossypium_raimondii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gossypium_raimondii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29730"]),
        None,
        Some("."),
        Some("Gorai"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vitis vinifera nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29760.VIT_00s0120g00010.t01";
/// let this_library_node_name2 = "29760.VIT_19s0177g00370.t01";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vitis_vinifera_node_name(this_library_node_name1));
/// assert!(is_valid_string_vitis_vinifera_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vitis_vinifera_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vitis_vinifera_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29760"]),
        None,
        Some("."),
        Some("VIT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gaeumannomyces graminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29850.GGTG_00001T0";
/// let this_library_node_name2 = "29850.GGTG_14463T0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gaeumannomyces_graminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gaeumannomyces_graminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gaeumannomyces_graminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gaeumannomyces_graminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29850"]),
        None,
        Some("."),
        Some("GGTG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichoderma virens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29875.EHK15120";
/// let this_library_node_name2 = "29875.EHK27525";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichoderma_virens_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichoderma_virens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichoderma_virens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichoderma_virens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29875"]),
        None,
        Some("."),
        Some("EHK"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporothrix schenckii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "29908.O74259";
/// let this_library_node_name2 = "29908.U7Q9N7";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporothrix_schenckii_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporothrix_schenckii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporothrix_schenckii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporothrix_schenckii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["29908"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Otolemur garnettii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "30611.ENSOGAP00000000002";
/// let this_library_node_name2 = "30611.ENSOGAP00000022605";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_otolemur_garnettii_node_name(this_library_node_name1));
/// assert!(is_valid_string_otolemur_garnettii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_otolemur_garnettii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_otolemur_garnettii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["30611"]),
        None,
        Some("."),
        Some("ENSOGAP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Takifugu rubripes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "31033.ENSTRUP00000000001";
/// let this_library_node_name2 = "31033.ENSTRUP00000047841";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_takifugu_rubripes_node_name(this_library_node_name1));
/// assert!(is_valid_string_takifugu_rubripes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_takifugu_rubripes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_takifugu_rubripes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["31033"]),
        None,
        Some("."),
        Some("ENSTRUP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caenorhabditis remanei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "31234.CRE00001";
/// let this_library_node_name2 = "31234.CRE32640";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caenorhabditis_remanei_node_name(this_library_node_name1));
/// assert!(is_valid_string_caenorhabditis_remanei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caenorhabditis_remanei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caenorhabditis_remanei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["31234"]),
        None,
        Some("."),
        Some("CRE"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Colletotrichum graminicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "31870.EFQ24841";
/// let this_library_node_name2 = "31870.EFQ36860";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_colletotrichum_graminicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_colletotrichum_graminicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_colletotrichum_graminicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_colletotrichum_graminicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["31870"]),
        None,
        Some("."),
        Some("EFQ"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium pseudolongum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "31954.BPSP_0003";
/// let this_library_node_name2 = "31954.BPSP_3090";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_pseudolongum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_pseudolongum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_pseudolongum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_pseudolongum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["31954"]),
        None,
        Some("."),
        Some("BPSP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clavibacter michiganensis sepedonicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "31964.CMS0001";
/// let this_library_node_name2 = "31964.pCSL0121";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clavibacter_michiganensis_sepedonicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_clavibacter_michiganensis_sepedonicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clavibacter_michiganensis_sepedonicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clavibacter_michiganensis_sepedonicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["31964"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter sputorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "32024.JMTI01000001_gene747";
/// let this_library_node_name2 = "32024.JMTI01000051_gene292";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_sputorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_sputorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_sputorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_sputorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["32024"]),
        None,
        Some("."),
        Some("JMTI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas stutzeri ATCC14405 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "32042.PstZobell_00005";
/// let this_library_node_name2 = "32042.PstZobell_21120";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_stutzeri_atcc14405_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_stutzeri_atcc14405_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_stutzeri_atcc14405_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_stutzeri_atcc14405_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["32042"]),
        None,
        Some("."),
        Some("PstZobell_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. PCC7002 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "32049.SYNPCC7002_A0001";
/// let this_library_node_name2 = "32049.SYNPCC7002_E0039";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_pcc7002_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_pcc7002_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_pcc7002_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_pcc7002_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["32049"]),
        None,
        Some("."),
        Some("SYNPCC7002_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. WH 7803 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "32051.SynWH7803_0001";
/// let this_library_node_name2 = "32051.SynWH7803_2533";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_wh_7803_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_wh_7803_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_wh_7803_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_wh_7803_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["32051"]),
        None,
        Some("."),
        Some("SynWH7803_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Calothrix sp. PCC7103 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "32057.KB217472_gene7841";
/// let this_library_node_name2 = "32057.KB217483_gene9999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_calothrix_sp_pcc7103_node_name(this_library_node_name1));
/// assert!(is_valid_string_calothrix_sp_pcc7103_node_name(this_library_node_name2));
/// assert!(!is_valid_string_calothrix_sp_pcc7103_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_calothrix_sp_pcc7103_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["32057"]),
        None,
        Some("."),
        Some("KB2174"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tetranychus urticae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "32264.tetur01g00010.1";
/// let this_library_node_name2 = "32264.tetur99g00020.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tetranychus_urticae_node_name(this_library_node_name1));
/// assert!(is_valid_string_tetranychus_urticae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tetranychus_urticae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tetranychus_urticae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["32264"]),
        None,
        Some("."),
        Some("tetur"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neolamprologus brichardi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "32507.XP_006779743.1";
/// let this_library_node_name2 = "32507.XP_006811101.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neolamprologus_brichardi_node_name(this_library_node_name1));
/// assert!(is_valid_string_neolamprologus_brichardi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neolamprologus_brichardi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neolamprologus_brichardi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["32507"]),
        None,
        Some("."),
        Some("XP_006"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blautia producta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "33035.JPJF01000001_gene2507";
/// let this_library_node_name2 = "33035.JPJF01000173_gene2454";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blautia_producta_node_name(this_library_node_name1));
/// assert!(is_valid_string_blautia_producta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blautia_producta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blautia_producta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["33035"]),
        None,
        Some("."),
        Some("JPJF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eremothecium gossypii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "33169.AAS50168";
/// let this_library_node_name2 = "33169.ADJ41804";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eremothecium_gossypii_node_name(this_library_node_name1));
/// assert!(is_valid_string_eremothecium_gossypii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eremothecium_gossypii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eremothecium_gossypii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["33169"]),
        None,
        Some("."),
        Some("A"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aspergillus terreus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "33178.CADATEAP00000001";
/// let this_library_node_name2 = "33178.CADATEAP00010402";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aspergillus_terreus_node_name(this_library_node_name1));
/// assert!(is_valid_string_aspergillus_terreus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aspergillus_terreus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aspergillus_terreus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["33178"]),
        None,
        Some("."),
        Some("CADATEAP000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Uncinocarpus reesii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "33188.XP_002540640.1";
/// let this_library_node_name2 = "33188.XP_002585383.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_uncinocarpus_reesii_node_name(this_library_node_name1));
/// assert!(is_valid_string_uncinocarpus_reesii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_uncinocarpus_reesii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_uncinocarpus_reesii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["33188"]),
        None,
        Some("."),
        Some("XP_0025"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Catenuloplanes japonicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "33876.JNXY01000001_gene5579";
/// let this_library_node_name2 = "33876.JNXY01000133_gene9291";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_catenuloplanes_japonicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_catenuloplanes_japonicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_catenuloplanes_japonicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_catenuloplanes_japonicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["33876"]),
        None,
        Some("."),
        Some("JNXY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces galbus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "33898.JRHJ01000001_gene548";
/// let this_library_node_name2 = "33898.JRHJ01000104_gene8440";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_galbus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_galbus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_galbus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_galbus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["33898"]),
        None,
        Some("."),
        Some("JRHJ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium thermophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "33905.BTHE_0001";
/// let this_library_node_name2 = "33905.BTHE_3000";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_thermophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_thermophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_thermophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_thermophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["33905"]),
        None,
        Some("."),
        Some("BTHE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus versutus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "34007.IT40_00010";
/// let this_library_node_name2 = "34007.IT40_27610";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_versutus_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_versutus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_versutus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_versutus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["34007"]),
        None,
        Some("."),
        Some("IT40_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mixia osmundae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "34349.G7DS01";
/// let this_library_node_name2 = "34349.G7EB76";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mixia_osmundae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mixia_osmundae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mixia_osmundae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mixia_osmundae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["34349"]),
        None,
        Some("."),
        Some("G7"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blumeria graminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "34373.CCU74152";
/// let this_library_node_name2 = "34373.CCU83285";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blumeria_graminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_blumeria_graminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blumeria_graminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blumeria_graminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["34373"]),
        None,
        Some("."),
        Some("CCU"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Strongyloides ratti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "34506.KOG0002.9";
/// let this_library_node_name2 = "34506.g999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_strongyloides_ratti_node_name(this_library_node_name1));
/// assert!(is_valid_string_strongyloides_ratti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_strongyloides_ratti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_strongyloides_ratti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["34506"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Heliconius melpomene nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "34740.HMEL000002-PA";
/// let this_library_node_name2 = "34740.HMEL026016-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_heliconius_melpomene_node_name(this_library_node_name1));
/// assert!(is_valid_string_heliconius_melpomene_node_name(this_library_node_name2));
/// assert!(!is_valid_string_heliconius_melpomene_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_heliconius_melpomene_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["34740"]),
        None,
        Some("."),
        Some("HMEL0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chinchilla lanigera nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "34839.XP_005372593.1";
/// let this_library_node_name2 = "34839.XP_005415467.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chinchilla_lanigera_node_name(this_library_node_name1));
/// assert!(is_valid_string_chinchilla_lanigera_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chinchilla_lanigera_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chinchilla_lanigera_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["34839"]),
        None,
        Some("."),
        Some("XP_005"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thalassiosira pseudonana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "35128.Thaps1000";
/// let this_library_node_name2 = "35128.Thapsdraft997";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thalassiosira_pseudonana_node_name(this_library_node_name1));
/// assert!(is_valid_string_thalassiosira_pseudonana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thalassiosira_pseudonana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thalassiosira_pseudonana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["35128"]),
        None,
        Some("."),
        Some("Thaps"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citrobacter amalonaticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "35703.DQ02_00005";
/// let this_library_node_name2 = "35703.DQ02_25770";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citrobacter_amalonaticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_citrobacter_amalonaticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citrobacter_amalonaticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citrobacter_amalonaticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["35703"]),
        None,
        Some("."),
        Some("DQ02_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thielavia terrestris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "35720.XP_003648512.1";
/// let this_library_node_name2 = "35720.XP_003658313.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thielavia_terrestris_node_name(this_library_node_name1));
/// assert!(is_valid_string_thielavia_terrestris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thielavia_terrestris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thielavia_terrestris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["35720"]),
        None,
        Some("."),
        Some("XP_0036"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Macrophomina phaseolina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "35725.K2QGD8";
/// let this_library_node_name2 = "35725.K2T134";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_macrophomina_phaseolina_node_name(this_library_node_name1));
/// assert!(is_valid_string_macrophomina_phaseolina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_macrophomina_phaseolina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_macrophomina_phaseolina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["35725"]),
        None,
        Some("."),
        Some("K2"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dactylosporangium aurantiacum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "35754.JNYJ01000001_gene7045";
/// let this_library_node_name2 = "35754.JNYJ01000228_gene7765";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dactylosporangium_aurantiacum_node_name(this_library_node_name1));
/// assert!(is_valid_string_dactylosporangium_aurantiacum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dactylosporangium_aurantiacum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dactylosporangium_aurantiacum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["35754"]),
        None,
        Some("."),
        Some("JNYJ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium choerinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "35760.BCHO_0002";
/// let this_library_node_name2 = "35760.BCHO_3002";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_choerinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_choerinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_choerinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_choerinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["35760"]),
        None,
        Some("."),
        Some("BCHO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus thermoamylovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "35841.BT1A1_0001";
/// let this_library_node_name2 = "35841.BT1A1_3536";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_thermoamylovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_thermoamylovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_thermoamylovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_thermoamylovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["35841"]),
        None,
        Some("."),
        Some("BT1A1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vanderwaltozyma polyspora nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "36033.XP_001642145.1";
/// let this_library_node_name2 = "36033.XP_001647511.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vanderwaltozyma_polyspora_node_name(this_library_node_name1));
/// assert!(is_valid_string_vanderwaltozyma_polyspora_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vanderwaltozyma_polyspora_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vanderwaltozyma_polyspora_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["36033"]),
        None,
        Some("."),
        Some("XP_00164"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mucor circinelloides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "36080.S2ITI7";
/// let this_library_node_name2 = "36080.S2KL40";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mucor_circinelloides_node_name(this_library_node_name1));
/// assert!(is_valid_string_mucor_circinelloides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mucor_circinelloides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mucor_circinelloides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["36080"]),
        None,
        Some("."),
        Some("S2"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pythium irregulare nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "36331.EPrPI00000013083";
/// let this_library_node_name2 = "36331.EPrPI00000026887";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pythium_irregulare_node_name(this_library_node_name1));
/// assert!(is_valid_string_pythium_irregulare_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pythium_irregulare_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pythium_irregulare_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["36331"]),
        None,
        Some("."),
        Some("EPrPI000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neosartorya fischeri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "36630.CADNFIAP00000001";
/// let this_library_node_name2 = "36630.CADNFIAP00010437";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neosartorya_fischeri_node_name(this_library_node_name1));
/// assert!(is_valid_string_neosartorya_fischeri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neosartorya_fischeri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neosartorya_fischeri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["36630"]),
        None,
        Some("."),
        Some("CADNFIAP000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Penicillium digitatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "36651.K9F3Z5";
/// let this_library_node_name2 = "36651.K9H4H3";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_penicillium_digitatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_penicillium_digitatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_penicillium_digitatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_penicillium_digitatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["36651"]),
        None,
        Some("."),
        Some("K9"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium abscessus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "36809.MAB_0001";
/// let this_library_node_name2 = "36809.MAB_p22c";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_abscessus_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_abscessus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_abscessus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_abscessus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["36809"]),
        None,
        Some("."),
        Some("MAB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wigglesworthia glossinidia sp. Gbr nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "36870.25165956";
/// let this_library_node_name2 = "36870.25166567";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wigglesworthia_glossinidia_sp_gbr_node_name(this_library_node_name1));
/// assert!(is_valid_string_wigglesworthia_glossinidia_sp_gbr_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wigglesworthia_glossinidia_sp_gbr_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wigglesworthia_glossinidia_sp_gbr_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["36870"]),
        None,
        Some("."),
        Some("2516"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas cangingivalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "36874.HQ34_00010";
/// let this_library_node_name2 = "36874.HQ34_10070";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_cangingivalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_cangingivalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_cangingivalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_cangingivalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["36874"]),
        None,
        Some("."),
        Some("HQ34_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas canoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "36875.HQ29_00030";
/// let this_library_node_name2 = "36875.HQ29_10360";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_canoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_canoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_canoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_canoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["36875"]),
        None,
        Some("."),
        Some("HQ29_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lodderomyces elongisporus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "36914.XP_001523057.1";
/// let this_library_node_name2 = "36914.XP_001528855.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lodderomyces_elongisporus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lodderomyces_elongisporus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lodderomyces_elongisporus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lodderomyces_elongisporus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["36914"]),
        None,
        Some("."),
        Some("XP_00152"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium algidicarnis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "37659.JNLN01000001_gene1";
/// let this_library_node_name2 = "37659.JNLN01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_algidicarnis_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_algidicarnis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_algidicarnis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_algidicarnis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["37659"]),
        None,
        Some("."),
        Some("JNLN01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aegilops tauschii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "37682.AFH89489";
/// let this_library_node_name2 = "37682.EMT33866";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aegilops_tauschii_node_name(this_library_node_name1));
/// assert!(is_valid_string_aegilops_tauschii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aegilops_tauschii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aegilops_tauschii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["37682"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytoplasma mali nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "37692.ATP_00001";
/// let this_library_node_name2 = "37692.ATP_00497";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytoplasma_mali_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytoplasma_mali_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytoplasma_mali_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytoplasma_mali_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["37692"]),
        None,
        Some("."),
        Some("ATP_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Talaromyces marneffei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "37727.XP_002143127.1";
/// let this_library_node_name2 = "37727.XP_002153764.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_talaromyces_marneffei_node_name(this_library_node_name1));
/// assert!(is_valid_string_talaromyces_marneffei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_talaromyces_marneffei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_talaromyces_marneffei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["37727"]),
        None,
        Some("."),
        Some("XP_0021"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus opacus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "37919.EP51_00005";
/// let this_library_node_name2 = "37919.EP51_46945";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_opacus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_opacus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_opacus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_opacus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["37919"]),
        None,
        Some("."),
        Some("EP51_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chaetomium globosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "38033.XP_001219222.1";
/// let this_library_node_name2 = "38033.XP_001230270.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chaetomium_globosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chaetomium_globosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chaetomium_globosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chaetomium_globosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["38033"]),
        None,
        Some("."),
        Some("XP_0012"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alligator sinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "38654.XP_006014702.1";
/// let this_library_node_name2 = "38654.XP_006039577.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alligator_sinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alligator_sinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alligator_sinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alligator_sinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["38654"]),
        None,
        Some("."),
        Some("XP_0060"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Panicum virgatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "38727.Pavir.Aa00001.1.p";
/// let this_library_node_name2 = "38727.Pavir.J41128.1.p";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_panicum_virgatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_panicum_virgatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_panicum_virgatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_panicum_virgatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["38727"]),
        None,
        Some("."),
        Some("Pavir"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Micromonas pusilla nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "38833.XP_003054756.1";
/// let this_library_node_name2 = "38833.XP_003064997.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_micromonas_pusilla_node_name(this_library_node_name1));
/// assert!(is_valid_string_micromonas_pusilla_node_name(this_library_node_name2));
/// assert!(!is_valid_string_micromonas_pusilla_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_micromonas_pusilla_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["38833"]),
        None,
        Some("."),
        Some("XP_0030"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tuber melanosporum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "39416.CAZ79182";
/// let this_library_node_name2 = "39416.CAZ86677";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tuber_melanosporum_node_name(this_library_node_name1));
/// assert!(is_valid_string_tuber_melanosporum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tuber_melanosporum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tuber_melanosporum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["39416"]),
        None,
        Some("."),
        Some("CAZ"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus equi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40041.SZO_00010";
/// let this_library_node_name2 = "40041.SZO_19410";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_equi_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_equi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_equi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_equi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40041"]),
        None,
        Some("."),
        Some("SZO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neurospora tetrasperma nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40127.XP_009847021.1";
/// let this_library_node_name2 = "40127.XP_009857400.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neurospora_tetrasperma_node_name(this_library_node_name1));
/// assert!(is_valid_string_neurospora_tetrasperma_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neurospora_tetrasperma_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neurospora_tetrasperma_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40127"]),
        None,
        Some("."),
        Some("XP_0098"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryza glumipatula nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40148.OGLUM01G00010.1";
/// let this_library_node_name2 = "40148.OGLUM12G22110.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryza_glumipatula_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryza_glumipatula_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryza_glumipatula_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryza_glumipatula_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40148"]),
        None,
        Some("."),
        Some("OGLUM"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryza meridionalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40149.OMERI01G00010.1";
/// let this_library_node_name2 = "40149.OMERI12G15280.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryza_meridionalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryza_meridionalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryza_meridionalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryza_meridionalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40149"]),
        None,
        Some("."),
        Some("OMERI"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter junii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40215.BBOS01000001_gene717";
/// let this_library_node_name2 = "40215.BBOS01000167_gene3434";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_junii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_junii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_junii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_junii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40215"]),
        None,
        Some("."),
        Some("BBOS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. CIPA165 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40373.F991_00001";
/// let this_library_node_name2 = "40373.F991_03432";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_cipa165_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_cipa165_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_cipa165_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_cipa165_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40373"]),
        None,
        Some("."),
        Some("F991_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aspergillus kawachii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40384.G7DRY5";
/// let this_library_node_name2 = "40384.Q96WQ9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aspergillus_kawachii_node_name(this_library_node_name1));
/// assert!(is_valid_string_aspergillus_kawachii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aspergillus_kawachii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aspergillus_kawachii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40384"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fomitopsis pinicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40483.S8DFS1";
/// let this_library_node_name2 = "40483.S8G823";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fomitopsis_pinicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_fomitopsis_pinicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fomitopsis_pinicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fomitopsis_pinicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40483"]),
        None,
        Some("."),
        Some("S8"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stereum hirsutum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40492.XP_007297917.1";
/// let this_library_node_name2 = "40492.XP_007311982.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stereum_hirsutum_node_name(this_library_node_name1));
/// assert!(is_valid_string_stereum_hirsutum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stereum_hirsutum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stereum_hirsutum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40492"]),
        None,
        Some("."),
        Some("XP_007"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Botrytis cinerea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40559.M7TAC5";
/// let this_library_node_name2 = "40559.M7V4Y2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_botrytis_cinerea_node_name(this_library_node_name1));
/// assert!(is_valid_string_botrytis_cinerea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_botrytis_cinerea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_botrytis_cinerea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40559"]),
        None,
        Some("."),
        Some("M7"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lentzea albidocapillata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "40571.JOEA01000001_gene5012";
/// let this_library_node_name2 = "40571.JOEA01000127_gene5876";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lentzea_albidocapillata_node_name(this_library_node_name1));
/// assert!(is_valid_string_lentzea_albidocapillata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lentzea_albidocapillata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lentzea_albidocapillata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["40571"]),
        None,
        Some("."),
        Some("JOEA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanothece sp. PCC8801 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "41431.PCC8801_0001";
/// let this_library_node_name2 = "41431.PCC8801_4555";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanothece_sp_pcc8801_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanothece_sp_pcc8801_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanothece_sp_pcc8801_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanothece_sp_pcc8801_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["41431"]),
        None,
        Some("."),
        Some("PCC8801_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bathycoccus prasinos nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "41875.XP_007508022.1";
/// let this_library_node_name2 = "41875.XP_007515828.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bathycoccus_prasinos_node_name(this_library_node_name1));
/// assert!(is_valid_string_bathycoccus_prasinos_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bathycoccus_prasinos_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bathycoccus_prasinos_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["41875"]),
        None,
        Some("."),
        Some("XP_0075"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pneumocystis jirovecii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "42068.L0P6P2";
/// let this_library_node_name2 = "42068.L0PIX4";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pneumocystis_jirovecii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pneumocystis_jirovecii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pneumocystis_jirovecii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pneumocystis_jirovecii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["42068"]),
        None,
        Some("."),
        Some("L0P"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pythium vexans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "42099.EPrPV00000013083";
/// let this_library_node_name2 = "42099.EPrPV00000025040";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pythium_vexans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pythium_vexans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pythium_vexans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pythium_vexans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["42099"]),
        None,
        Some("."),
        Some("EPrPV000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sorex araneus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "42254.XP_004600151.1";
/// let this_library_node_name2 = "42254.XP_004622923.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sorex_araneus_node_name(this_library_node_name1));
/// assert!(is_valid_string_sorex_araneus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sorex_araneus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sorex_araneus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["42254"]),
        None,
        Some("."),
        Some("XP_0046"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rubrobacter radiotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "42256.RradSPS_0001";
/// let this_library_node_name2 = "42256.RradSPS_3161";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rubrobacter_radiotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_rubrobacter_radiotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rubrobacter_radiotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rubrobacter_radiotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["42256"]),
        None,
        Some("."),
        Some("RradSPS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phoenix dactylifera nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "42345.XP_008774989.1";
/// let this_library_node_name2 = "42345.XP_008813839.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phoenix_dactylifera_node_name(this_library_node_name1));
/// assert!(is_valid_string_phoenix_dactylifera_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phoenix_dactylifera_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phoenix_dactylifera_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["42345"]),
        None,
        Some("."),
        Some("XP_008"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Candida dubliniensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "42374.XP_002416683.1";
/// let this_library_node_name2 = "42374.XP_002422542.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_candida_dubliniensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_candida_dubliniensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_candida_dubliniensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_candida_dubliniensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["42374"]),
        None,
        Some("."),
        Some("XP_0024"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas salina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "42565.FP66_00005";
/// let this_library_node_name2 = "42565.FP66_16205";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_salina_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_salina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_salina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_salina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["42565"]),
        None,
        Some("."),
        Some("FP66_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anopheles darlingi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "43151.ADAC000001-PA";
/// let this_library_node_name2 = "43151.ADAC011085-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anopheles_darlingi_node_name(this_library_node_name1));
/// assert!(is_valid_string_anopheles_darlingi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anopheles_darlingi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anopheles_darlingi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["43151"]),
        None,
        Some("."),
        Some("ADAC0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ictidomys tridecemlineatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "43179.ENSSTOP00000000001";
/// let this_library_node_name2 = "43179.ENSSTOP00000023972";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ictidomys_tridecemlineatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ictidomys_tridecemlineatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ictidomys_tridecemlineatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ictidomys_tridecemlineatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["43179"]),
        None,
        Some("."),
        Some("ENSSTOP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capronia epimyces nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "43228.XP_007728343.1";
/// let this_library_node_name2 = "43228.XP_007738811.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capronia_epimyces_node_name(this_library_node_name1));
/// assert!(is_valid_string_capronia_epimyces_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capronia_epimyces_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capronia_epimyces_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["43228"]),
        None,
        Some("."),
        Some("XP_0077"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capronia coronata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "43229.XP_007719112.1";
/// let this_library_node_name2 = "43229.XP_007728342.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capronia_coronata_node_name(this_library_node_name1));
/// assert!(is_valid_string_capronia_coronata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capronia_coronata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capronia_coronata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["43229"]),
        None,
        Some("."),
        Some("XP_0077"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prauserella rugosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "43354.JOIJ01000001_gene1";
/// let this_library_node_name2 = "43354.JOIJ01000091_gene3215";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prauserella_rugosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_prauserella_rugosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prauserella_rugosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prauserella_rugosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["43354"]),
        None,
        Some("."),
        Some("JOIJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces wedmorensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "43759.JNWK01000001_gene5551";
/// let this_library_node_name2 = "43759.JNWK01000259_gene2367";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_wedmorensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_wedmorensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_wedmorensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_wedmorensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["43759"]),
        None,
        Some("."),
        Some("JNWK01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanothece sp. ATCC51142 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "43989.cce_0001";
/// let this_library_node_name2 = "43989.cce_5310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanothece_sp_atcc51142_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanothece_sp_atcc51142_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanothece_sp_atcc51142_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanothece_sp_atcc51142_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["43989"]),
        None,
        Some("."),
        Some("cce_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aureococcus anophagefferens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "44056.XP_009032083.1";
/// let this_library_node_name2 = "44056.XP_009043602.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aureococcus_anophagefferens_node_name(this_library_node_name1));
/// assert!(is_valid_string_aureococcus_anophagefferens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aureococcus_anophagefferens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aureococcus_anophagefferens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["44056"]),
        None,
        Some("."),
        Some("XP_0090"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces megasporus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "44060.JODL01000001_gene2931";
/// let this_library_node_name2 = "44060.JODL01000194_gene3817";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_megasporus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_megasporus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_megasporus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_megasporus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["44060"]),
        None,
        Some("."),
        Some("JODL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus durus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "44251.PDUR_00005";
/// let this_library_node_name2 = "44251.PDUR_28045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_durus_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_durus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_durus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_durus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["44251"]),
        None,
        Some("."),
        Some("PDUR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium avium avium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "44454.NF84_00005";
/// let this_library_node_name2 = "44454.NF84_23310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_avium_avium_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_avium_avium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_avium_avium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_avium_avium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["44454"]),
        None,
        Some("."),
        Some("NF84_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dictyostelium discoideum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "44689.DDB0166992";
/// let this_library_node_name2 = "44689.DDB0305310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dictyostelium_discoideum_node_name(this_library_node_name1));
/// assert!(is_valid_string_dictyostelium_discoideum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dictyostelium_discoideum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dictyostelium_discoideum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["44689"]),
        None,
        Some("."),
        Some("DDB0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bipolaris sorokiniana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "45130.XP_007694045.1";
/// let this_library_node_name2 = "45130.XP_007706258.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bipolaris_sorokiniana_node_name(this_library_node_name1));
/// assert!(is_valid_string_bipolaris_sorokiniana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bipolaris_sorokiniana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bipolaris_sorokiniana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["45130"]),
        None,
        Some("."),
        Some("XP_007"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrenophora triticirepentis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "45151.EDU39439";
/// let this_library_node_name2 = "45151.EDU51607";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrenophora_triticirepentis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrenophora_triticirepentis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrenophora_triticirepentis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrenophora_triticirepentis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["45151"]),
        None,
        Some("."),
        Some("EDU"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanidioschyzon merolae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "45157.CMA001CT";
/// let this_library_node_name2 = "45157.CMX011CT";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanidioschyzon_merolae_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanidioschyzon_merolae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanidioschyzon_merolae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanidioschyzon_merolae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["45157"]),
        None,
        Some("."),
        Some("CM"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eremothecium cymbalariae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "45285.XP_003644078.1";
/// let this_library_node_name2 = "45285.XP_003648511.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eremothecium_cymbalariae_node_name(this_library_node_name1));
/// assert!(is_valid_string_eremothecium_cymbalariae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eremothecium_cymbalariae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eremothecium_cymbalariae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["45285"]),
        None,
        Some("."),
        Some("XP_00364"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nematostella vectensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "45351.EDO25302";
/// let this_library_node_name2 = "45351.EDO50081";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nematostella_vectensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nematostella_vectensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nematostella_vectensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nematostella_vectensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["45351"]),
        None,
        Some("."),
        Some("EDO"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma conjunctivae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "45361.MCJ_000010";
/// let this_library_node_name2 = "45361.MCJ_007340";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_conjunctivae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_conjunctivae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_conjunctivae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_conjunctivae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["45361"]),
        None,
        Some("."),
        Some("MCJ_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Candida tenuis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "45596.XP_006683576.1";
/// let this_library_node_name2 = "45596.XP_006690560.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_candida_tenuis_node_name(this_library_node_name1));
/// assert!(is_valid_string_candida_tenuis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_candida_tenuis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_candida_tenuis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["45596"]),
        None,
        Some("."),
        Some("XP_0066"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anabaena sp. 90 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "46234.ANA_C10001";
/// let this_library_node_name2 = "46234.ANA_C20755";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anabaena_sp_90_node_name(this_library_node_name1));
/// assert!(is_valid_string_anabaena_sp_90_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anabaena_sp_90_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anabaena_sp_90_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["46234"]),
        None,
        Some("."),
        Some("ANA_C"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Weissella hellenica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "46256.BBIK01000001_gene1";
/// let this_library_node_name2 = "46256.BBIK01000030_gene1879";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_weissella_hellenica_node_name(this_library_node_name1));
/// assert!(is_valid_string_weissella_hellenica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_weissella_hellenica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_weissella_hellenica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["46256"]),
        None,
        Some("."),
        Some("BBIK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium chlorophenolicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "46429.BV95_00001";
/// let this_library_node_name2 = "46429.BV95_04536";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_chlorophenolicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_chlorophenolicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_chlorophenolicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_chlorophenolicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["46429"]),
        None,
        Some("."),
        Some("BV95_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Entamoeba dispar nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "46681.XP_001733219.1";
/// let this_library_node_name2 = "46681.XP_001742030.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_entamoeba_dispar_node_name(this_library_node_name1));
/// assert!(is_valid_string_entamoeba_dispar_node_name(this_library_node_name2));
/// assert!(!is_valid_string_entamoeba_dispar_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_entamoeba_dispar_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["46681"]),
        None,
        Some("."),
        Some("XP_0017"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces olivaceus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "47716.JOFH01000001_gene2087";
/// let this_library_node_name2 = "47716.JOFH01000188_gene4";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_olivaceus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_olivaceus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_olivaceus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_olivaceus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["47716"]),
        None,
        Some("."),
        Some("JOFH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces lydicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "47763.JNZA01000001_gene4170";
/// let this_library_node_name2 = "47763.JNZA01000131_gene5004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_lydicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_lydicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_lydicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_lydicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["47763"]),
        None,
        Some("."),
        Some("JNZA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium triplex nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "47839.CCAU010000001_gene2871";
/// let this_library_node_name2 = "47839.CCAU010000021_gene3128";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_triplex_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_triplex_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_triplex_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_triplex_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["47839"]),
        None,
        Some("."),
        Some("CCAU0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Poecilia formosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "48698.ENSPFOP00000000001";
/// let this_library_node_name2 = "48698.ENSPFOP00000031312";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_poecilia_formosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_poecilia_formosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_poecilia_formosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_poecilia_formosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["48698"]),
        None,
        Some("."),
        Some("ENSPFOP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arabis alpina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "50452.A0A075C3A5";
/// let this_library_node_name2 = "50452.W0USV0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arabis_alpina_node_name(this_library_node_name1));
/// assert!(is_valid_string_arabis_alpina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arabis_alpina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arabis_alpina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["50452"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter trogontum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "50960.LS81_00005";
/// let this_library_node_name2 = "50960.LS81_13005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_trogontum_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_trogontum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_trogontum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_trogontum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["50960"]),
        None,
        Some("."),
        Some("LS81_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Jaculus jaculus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "51337.XP_004649172.1";
/// let this_library_node_name2 = "51337.XP_004673406.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_jaculus_jaculus_node_name(this_library_node_name1));
/// assert!(is_valid_string_jaculus_jaculus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_jaculus_jaculus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_jaculus_jaculus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["51337"]),
        None,
        Some("."),
        Some("XP_0046"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichoderma reesei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "51453.EGR44033";
/// let this_library_node_name2 = "51453.EGR53147";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichoderma_reesei_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichoderma_reesei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichoderma_reesei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichoderma_reesei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["51453"]),
        None,
        Some("."),
        Some("EGR"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ciona savignyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "51511.ENSCSAVP00000000001";
/// let this_library_node_name2 = "51511.ENSCSAVP00000020162";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ciona_savignyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_ciona_savignyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ciona_savignyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ciona_savignyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["51511"]),
        None,
        Some("."),
        Some("ENSCSAVP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfitobacter sp. EE36 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "52598.EE36_00015";
/// let this_library_node_name2 = "52598.EE36_17452";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfitobacter_sp_ee36_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfitobacter_sp_ee36_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfitobacter_sp_ee36_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfitobacter_sp_ee36_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["52598"]),
        None,
        Some("."),
        Some("EE36_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haliaeetus leucocephalus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "52644.XP_010559315.1";
/// let this_library_node_name2 = "52644.XP_010584579.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haliaeetus_leucocephalus_node_name(this_library_node_name1));
/// assert!(is_valid_string_haliaeetus_leucocephalus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haliaeetus_leucocephalus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haliaeetus_leucocephalus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["52644"]),
        None,
        Some("."),
        Some("XP_0105"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrenophora teres nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "53485.EFQ84854";
/// let this_library_node_name2 = "53485.EFQ96652";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrenophora_teres_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrenophora_teres_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrenophora_teres_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrenophora_teres_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["53485"]),
        None,
        Some("."),
        Some("EFQ"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pectobacterium betavasculorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "55207.KP22_00010";
/// let this_library_node_name2 = "55207.KP22_21715";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pectobacterium_betavasculorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_pectobacterium_betavasculorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pectobacterium_betavasculorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pectobacterium_betavasculorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["55207"]),
        None,
        Some("."),
        Some("KP22_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Guillardia theta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "55529.AAC35594";
/// let this_library_node_name2 = "55529.EKX55560";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_guillardia_theta_node_name(this_library_node_name1));
/// assert!(is_valid_string_guillardia_theta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_guillardia_theta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_guillardia_theta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["55529"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio anguillarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "55601.VANGNB10_67p002";
/// let this_library_node_name2 = "55601.VANGNB10_cII1021c";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_anguillarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_anguillarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_anguillarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_anguillarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["55601"]),
        None,
        Some("."),
        Some("VANGNB10_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces toyocaensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "55952.BU52_00010";
/// let this_library_node_name2 = "55952.BU52_33600";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_toyocaensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_toyocaensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_toyocaensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_toyocaensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["55952"]),
        None,
        Some("."),
        Some("BU52_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cylindrospermum stagnale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "56107.Cylst_0001";
/// let this_library_node_name2 = "56107.Cylst_6379";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cylindrospermum_stagnale_node_name(this_library_node_name1));
/// assert!(is_valid_string_cylindrospermum_stagnale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cylindrospermum_stagnale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cylindrospermum_stagnale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["56107"]),
        None,
        Some("."),
        Some("Cylst_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oscillatoria acuminata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "56110.Oscil6304_0001";
/// let this_library_node_name2 = "56110.Oscil6304_6060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oscillatoria_acuminata_node_name(this_library_node_name1));
/// assert!(is_valid_string_oscillatoria_acuminata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oscillatoria_acuminata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oscillatoria_acuminata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["56110"]),
        None,
        Some("."),
        Some("Oscil6304_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Syntrophus aciditrophicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "56780.SYN_00001";
/// let this_library_node_name2 = "56780.SYN_03862";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_syntrophus_aciditrophicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_syntrophus_aciditrophicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_syntrophus_aciditrophicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_syntrophus_aciditrophicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["56780"]),
        None,
        Some("."),
        Some("SYN_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fragaria vesca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "57918.XP_004287057.1";
/// let this_library_node_name2 = "57918.XP_004310290.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fragaria_vesca_node_name(this_library_node_name1));
/// assert!(is_valid_string_fragaria_vesca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fragaria_vesca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fragaria_vesca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["57918"]),
        None,
        Some("."),
        Some("XP_004"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirillospora albida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "58123.JOFJ01000001_gene2863";
/// let this_library_node_name2 = "58123.JOFJ01000092_gene1198";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirillospora_albida_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirillospora_albida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirillospora_albida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirillospora_albida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["58123"]),
        None,
        Some("."),
        Some("JOFJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces celluloflavus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "58344.JOEL01000001_gene270";
/// let this_library_node_name2 = "58344.JOEL01000193_gene5534";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_celluloflavus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_celluloflavus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_celluloflavus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_celluloflavus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["58344"]),
        None,
        Some("."),
        Some("JOEL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsiella grylli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59196.RICGR_0001";
/// let this_library_node_name2 = "59196.RICGR_1567";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsiella_grylli_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsiella_grylli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsiella_grylli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsiella_grylli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59196"]),
        None,
        Some("."),
        Some("RICGR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fibrobacter succinogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59374.Fisuc_0001";
/// let this_library_node_name2 = "59374.Fisuc_3120";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fibrobacter_succinogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_fibrobacter_succinogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fibrobacter_succinogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fibrobacter_succinogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59374"]),
        None,
        Some("."),
        Some("Fisuc_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myotis lucifugus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59463.ENSMLUP00000000002";
/// let this_library_node_name2 = "59463.ENSMLUP00000022805";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myotis_lucifugus_node_name(this_library_node_name1));
/// assert!(is_valid_string_myotis_lucifugus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myotis_lucifugus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myotis_lucifugus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59463"]),
        None,
        Some("."),
        Some("ENSMLUP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantholops hodgsonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59538.XP_005953753.1";
/// let this_library_node_name2 = "59538.XP_005986018.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantholops_hodgsonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantholops_hodgsonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantholops_hodgsonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantholops_hodgsonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59538"]),
        None,
        Some("."),
        Some("XP_0059"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arabidopsis lyrata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59689.Al_scaffold_0001_1000";
/// let this_library_node_name2 = "59689.scaffold_98900002.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arabidopsis_lyrata_node_name(this_library_node_name1));
/// assert!(is_valid_string_arabidopsis_lyrata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arabidopsis_lyrata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arabidopsis_lyrata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59689"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytoplasma australiense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59748.PA0001";
/// let this_library_node_name2 = "59748.PA0840";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytoplasma_australiense_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytoplasma_australiense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytoplasma_australiense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytoplasma_australiense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59748"]),
        None,
        Some("."),
        Some("PA0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ficedula albicollis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59894.ENSFALP00000000001";
/// let this_library_node_name2 = "59894.ENSFALP00000015983";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ficedula_albicollis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ficedula_albicollis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ficedula_albicollis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ficedula_albicollis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59894"]),
        None,
        Some("."),
        Some("ENSFALP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus pastoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59919.PMM0001";
/// let this_library_node_name2 = "59919.PMM2077";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_pastoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_pastoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_pastoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_pastoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59919"]),
        None,
        Some("."),
        Some("PMM"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9107 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59921.EU92_0001";
/// let this_library_node_name2 = "59921.EU92_2029";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9107_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9107_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9107_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9107_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59921"]),
        None,
        Some("."),
        Some("EU92_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus GP2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59925.EU91_0001";
/// let this_library_node_name2 = "59925.EU91_1923";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_gp2_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_gp2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_gp2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_gp2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59925"]),
        None,
        Some("."),
        Some("EU91_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus SB nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59926.EV02_0001";
/// let this_library_node_name2 = "59926.EV02_1972";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_sb_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_sb_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_sb_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_sb_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59926"]),
        None,
        Some("."),
        Some("EV02_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. WH 7805 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "59931.WH7805_00005";
/// let this_library_node_name2 = "59931.WH7805_14488";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_wh_7805_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_wh_7805_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_wh_7805_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_wh_7805_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["59931"]),
        None,
        Some("."),
        Some("WH7805_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus paraplantarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "60520.HR47_00005";
/// let this_library_node_name2 = "60520.HR47_14845";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_paraplantarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_paraplantarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_paraplantarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_paraplantarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["60520"]),
        None,
        Some("."),
        Some("HR47_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorocebus sabaeus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "60711.ENSCSAP00000000001";
/// let this_library_node_name2 = "60711.ENSCSAP00000019255";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorocebus_sabaeus_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorocebus_sabaeus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorocebus_sabaeus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorocebus_sabaeus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["60711"]),
        None,
        Some("."),
        Some("ENSCSAP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ophiostoma piceae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "61273.S3BLL1";
/// let this_library_node_name2 = "61273.S3DBQ2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ophiostoma_piceae_node_name(this_library_node_name1));
/// assert!(is_valid_string_ophiostoma_piceae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ophiostoma_piceae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ophiostoma_piceae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["61273"]),
        None,
        Some("."),
        Some("S3"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coniosporium apollinis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "61459.XP_007776109.1";
/// let this_library_node_name2 = "61459.XP_007785416.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coniosporium_apollinis_node_name(this_library_node_name1));
/// assert!(is_valid_string_coniosporium_apollinis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coniosporium_apollinis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coniosporium_apollinis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["61459"]),
        None,
        Some("."),
        Some("XP_0077"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhinopithecus roxellana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "61622.XP_010350802.1";
/// let this_library_node_name2 = "61622.XP_010388077.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhinopithecus_roxellana_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhinopithecus_roxellana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhinopithecus_roxellana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhinopithecus_roxellana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["61622"]),
        None,
        Some("."),
        Some("XP_0103"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pluralibacter gergoviae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "61647.LG71_00010";
/// let this_library_node_name2 = "61647.LG71_25645";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pluralibacter_gergoviae_node_name(this_library_node_name1));
/// assert!(is_valid_string_pluralibacter_gergoviae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pluralibacter_gergoviae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pluralibacter_gergoviae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["61647"]),
        None,
        Some("."),
        Some("LG71_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nomascus leucogenys nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "61853.ENSNLEP00000000001";
/// let this_library_node_name2 = "61853.ENSNLEP00000024476";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nomascus_leucogenys_node_name(this_library_node_name1));
/// assert!(is_valid_string_nomascus_leucogenys_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nomascus_leucogenys_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nomascus_leucogenys_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["61853"]),
        None,
        Some("."),
        Some("ENSNLEP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Azoarcus sp. BH72 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "62928.azo0001";
/// let this_library_node_name2 = "62928.azo3992";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_azoarcus_sp_bh72_node_name(this_library_node_name1));
/// assert!(is_valid_string_azoarcus_sp_bh72_node_name(this_library_node_name2));
/// assert!(!is_valid_string_azoarcus_sp_bh72_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_azoarcus_sp_bh72_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["62928"]),
        None,
        Some("."),
        Some("azo"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. ADP1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "62977.ACIAD0001";
/// let this_library_node_name2 = "62977.ACIAD3684";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_adp1_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_adp1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_adp1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_adp1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["62977"]),
        None,
        Some("."),
        Some("ACIAD"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthroderma benhamiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "63400.XP_003009846.1";
/// let this_library_node_name2 = "63400.XP_003017825.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthroderma_benhamiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthroderma_benhamiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthroderma_benhamiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthroderma_benhamiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["63400"]),
        None,
        Some("."),
        Some("XP_0030"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microsporum gypseum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "63402.XP_003169023.1";
/// let this_library_node_name2 = "63402.XP_003177929.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microsporum_gypseum_node_name(this_library_node_name1));
/// assert!(is_valid_string_microsporum_gypseum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microsporum_gypseum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microsporum_gypseum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["63402"]),
        None,
        Some("."),
        Some("XP_0031"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthroderma otae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "63405.XP_002842557.1";
/// let this_library_node_name2 = "63405.XP_002851321.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthroderma_otae_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthroderma_otae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthroderma_otae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthroderma_otae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["63405"]),
        None,
        Some("."),
        Some("XP_0028"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichophyton equinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "63418.F2PGC7";
/// let this_library_node_name2 = "63418.F2Q652";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichophyton_equinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichophyton_equinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichophyton_equinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichophyton_equinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["63418"]),
        None,
        Some("."),
        Some("F2"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichoderma atroviride nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "63577.G9NDW1";
/// let this_library_node_name2 = "63577.G9PCM6";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichoderma_atroviride_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichoderma_atroviride_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichoderma_atroviride_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichoderma_atroviride_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["63577"]),
        None,
        Some("."),
        Some("G9"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nostoc punctiforme nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "63737.Npun_DF002";
/// let this_library_node_name2 = "63737.Npun_R6632";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nostoc_punctiforme_node_name(this_library_node_name1));
/// assert!(is_valid_string_nostoc_punctiforme_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nostoc_punctiforme_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nostoc_punctiforme_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["63737"]),
        None,
        Some("."),
        Some("Npun_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycosphaerella pini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "64363.EME38013";
/// let this_library_node_name2 = "64363.EME50427";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycosphaerella_pini_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycosphaerella_pini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycosphaerella_pini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycosphaerella_pini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["64363"]),
        None,
        Some("."),
        Some("EME"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. CC9311 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "64471.sync_0001";
/// let this_library_node_name2 = "64471.sync_2944";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_cc9311_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_cc9311_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_cc9311_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_cc9311_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["64471"]),
        None,
        Some("."),
        Some("sync_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pythium ultimum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "65071.PYU1_T000001";
/// let this_library_node_name2 = "65071.PYU1_T015330";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pythium_ultimum_node_name(this_library_node_name1));
/// assert!(is_valid_string_pythium_ultimum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pythium_ultimum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pythium_ultimum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["65071"]),
        None,
        Some("."),
        Some("PYU1_T0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halothece sp. PCC7418 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "65093.PCC7418_0001";
/// let this_library_node_name2 = "65093.PCC7418_3863";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halothece_sp_pcc7418_node_name(this_library_node_name1));
/// assert!(is_valid_string_halothece_sp_pcc7418_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halothece_sp_pcc7418_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halothece_sp_pcc7418_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["65093"]),
        None,
        Some("."),
        Some("PCC7418_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanothece sp. PCC7424 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "65393.PCC7424_0001";
/// let this_library_node_name2 = "65393.PCC7424_5890";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanothece_sp_pcc7424_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanothece_sp_pcc7424_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanothece_sp_pcc7424_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanothece_sp_pcc7424_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["65393"]),
        None,
        Some("."),
        Some("PCC7424_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oryza barthii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "65489.OBART01G00010.1";
/// let this_library_node_name2 = "65489.OBART12G20310.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oryza_barthii_node_name(this_library_node_name1));
/// assert!(is_valid_string_oryza_barthii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oryza_barthii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oryza_barthii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["65489"]),
        None,
        Some("."),
        Some("OBART"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinoalloteichus cyanogriseus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "65497.JODV01000001_gene3425";
/// let this_library_node_name2 = "65497.JODV01000151_gene1389";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinoalloteichus_cyanogriseus_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinoalloteichus_cyanogriseus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinoalloteichus_cyanogriseus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinoalloteichus_cyanogriseus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["65497"]),
        None,
        Some("."),
        Some("JODV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Piriformospora indica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "65672.G4T4S2";
/// let this_library_node_name2 = "65672.G4U3G4";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_piriformospora_indica_node_name(this_library_node_name1));
/// assert!(is_valid_string_piriformospora_indica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_piriformospora_indica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_piriformospora_indica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["65672"]),
        None,
        Some("."),
        Some("G4"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea stewartii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "66269.NL54_00005";
/// let this_library_node_name2 = "66269.NL54_22370";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_stewartii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_stewartii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_stewartii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_stewartii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["66269"]),
        None,
        Some("."),
        Some("NL54_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces niger nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "66373.JOFQ01000001_gene1462";
/// let this_library_node_name2 = "66373.JOFQ01000108_gene4246";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_niger_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_niger_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_niger_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_niger_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["66373"]),
        None,
        Some("."),
        Some("JOFQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces violens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "66377.JOBH01000001_gene1082";
/// let this_library_node_name2 = "66377.JOBH01000064_gene5664";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_violens_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_violens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_violens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_violens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["66377"]),
        None,
        Some("."),
        Some("JOBH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces roseoverticillatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "66429.JOFL01000001_gene4346";
/// let this_library_node_name2 = "66429.JOFL01000096_gene4968";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_roseoverticillatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_roseoverticillatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_roseoverticillatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_roseoverticillatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["66429"]),
        None,
        Some("."),
        Some("JOFL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus clausii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "66692.ABC0001";
/// let this_library_node_name2 = "66692.ABC4121";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_clausii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_clausii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_clausii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_clausii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["66692"]),
        None,
        Some("."),
        Some("ABC"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces atroolivaceus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "66869.JNXG01000001_gene3525";
/// let this_library_node_name2 = "66869.JNXG01000106_gene3408";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_atroolivaceus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_atroolivaceus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_atroolivaceus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_atroolivaceus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["66869"]),
        None,
        Some("."),
        Some("JNXG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces bicolor nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "66874.JOFS01000001_gene1000";
/// let this_library_node_name2 = "66874.JOFS01000183_gene198";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_bicolor_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_bicolor_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_bicolor_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_bicolor_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["66874"]),
        None,
        Some("."),
        Some("JOFS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces catenulae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "66875.JODY01000001_gene4425";
/// let this_library_node_name2 = "66875.JODY01000089_gene2095";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_catenulae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_catenulae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_catenulae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_catenulae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["66875"]),
        None,
        Some("."),
        Some("JODY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces griseorubens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "66897.DJ64_00005";
/// let this_library_node_name2 = "66897.DJ64_35400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_griseorubens_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_griseorubens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_griseorubens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_griseorubens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["66897"]),
        None,
        Some("."),
        Some("DJ64_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces albus albus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "67257.JODR01000001_gene1000";
/// let this_library_node_name2 = "67257.JODR01000104_gene6316";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_albus_albus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_albus_albus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_albus_albus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_albus_albus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["67257"]),
        None,
        Some("."),
        Some("JODR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces alboflavus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "67267.JNXT01000001_gene5605";
/// let this_library_node_name2 = "67267.JNXT01000169_gene7693";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_alboflavus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_alboflavus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_alboflavus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_alboflavus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["67267"]),
        None,
        Some("."),
        Some("JNXT01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces aureocirculatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "67275.JOAP01000001_gene2465";
/// let this_library_node_name2 = "67275.JOAP01000221_gene3166";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_aureocirculatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_aureocirculatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_aureocirculatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_aureocirculatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["67275"]),
        None,
        Some("."),
        Some("JOAP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces californicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "67281.JNZZ01000001_gene2021";
/// let this_library_node_name2 = "67281.JNZZ01000105_gene4075";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_californicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_californicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_californicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_californicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["67281"]),
        None,
        Some("."),
        Some("JNZZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces lavenduligriseus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "67315.JOBD01000001_gene1000";
/// let this_library_node_name2 = "67315.JOBD01000217_gene4318";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_lavenduligriseus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_lavenduligriseus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_lavenduligriseus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_lavenduligriseus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["67315"]),
        None,
        Some("."),
        Some("JOBD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces mutabilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "67332.FM21_00005";
/// let this_library_node_name2 = "67332.FM21_36480";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_mutabilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_mutabilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_mutabilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_mutabilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["67332"]),
        None,
        Some("."),
        Some("FM21_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces purpeofuscus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "67352.JODS01000001_gene100";
/// let this_library_node_name2 = "67352.JODS01000138_gene7695";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_purpeofuscus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_purpeofuscus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_purpeofuscus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_purpeofuscus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["67352"]),
        None,
        Some("."),
        Some("JODS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces resistomycificus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "67356.KL575585_gene8012";
/// let this_library_node_name2 = "67356.KL575698_gene6422";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_resistomycificus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_resistomycificus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_resistomycificus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_resistomycificus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["67356"]),
        None,
        Some("."),
        Some("KL575"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces varsoviensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "67373.JOBF01000001_gene5854";
/// let this_library_node_name2 = "67373.JOBF01000114_gene7009";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_varsoviensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_varsoviensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_varsoviensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_varsoviensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["67373"]),
        None,
        Some("."),
        Some("JOBF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytophthora sojae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "67593.Physo108136";
/// let this_library_node_name2 = "67593.Physo158990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytophthora_sojae_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytophthora_sojae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytophthora_sojae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytophthora_sojae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["67593"]),
        None,
        Some("."),
        Some("Physo1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lechevalieria aerocolonigenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "68170.KL590469_gene1407";
/// let this_library_node_name2 = "68170.KL590588_gene9504";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lechevalieria_aerocolonigenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_lechevalieria_aerocolonigenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lechevalieria_aerocolonigenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lechevalieria_aerocolonigenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["68170"]),
        None,
        Some("."),
        Some("KL590"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces durhamensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "68194.JNXR01000001_gene6554";
/// let this_library_node_name2 = "68194.JNXR01000228_gene1756";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_durhamensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_durhamensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_durhamensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_durhamensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["68194"]),
        None,
        Some("."),
        Some("JNXR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces flavochromogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "68199.JNZO01000001_gene1000";
/// let this_library_node_name2 = "68199.JNZO01000168_gene751";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_flavochromogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_flavochromogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_flavochromogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_flavochromogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["68199"]),
        None,
        Some("."),
        Some("JNZO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces iakyrus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "68219.JNXI01000001_gene5826";
/// let this_library_node_name2 = "68219.JNXI01000181_gene2514";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_iakyrus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_iakyrus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_iakyrus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_iakyrus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["68219"]),
        None,
        Some("."),
        Some("JNXI01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces katrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "68223.JNZY01000001_gene5395";
/// let this_library_node_name2 = "68223.JNZY01000150_gene443";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_katrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_katrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_katrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_katrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["68223"]),
        None,
        Some("."),
        Some("JNZY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces pyridomyceticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "68260.JOAY01000001_gene3575";
/// let this_library_node_name2 = "68260.JOAY01000139_gene2407";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_pyridomyceticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_pyridomyceticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_pyridomyceticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_pyridomyceticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["68260"]),
        None,
        Some("."),
        Some("JOAY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces albulus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "68570.DC74_1";
/// let this_library_node_name2 = "68570.DC74_p00033";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_albulus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_albulus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_albulus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_albulus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["68570"]),
        None,
        Some("."),
        Some("DC74_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Theileria orientalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "68886.XP_009688833.1";
/// let this_library_node_name2 = "68886.XP_009692827.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_theileria_orientalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_theileria_orientalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_theileria_orientalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_theileria_orientalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["68886"]),
        None,
        Some("."),
        Some("XP_0096"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermococcus kodakarensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "69014.TK0001";
/// let this_library_node_name2 = "69014.TK2306";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermococcus_kodakarensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermococcus_kodakarensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermococcus_kodakarensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermococcus_kodakarensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["69014"]),
        None,
        Some("."),
        Some("TK"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. WH 5701 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "69042.WH5701_00005";
/// let this_library_node_name2 = "69042.WH5701_16840";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_wh_5701_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_wh_5701_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_wh_5701_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_wh_5701_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["69042"]),
        None,
        Some("."),
        Some("WH5701_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquamicrobium defluvii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "69279.BG36_00010";
/// let this_library_node_name2 = "69279.BG36_24425";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquamicrobium_defluvii_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquamicrobium_defluvii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquamicrobium_defluvii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquamicrobium_defluvii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["69279"]),
        None,
        Some("."),
        Some("BG36_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gasterosteus aculeatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "69293.ENSGACP00000000002";
/// let this_library_node_name2 = "69293.ENSGACP00000027673";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gasterosteus_aculeatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_gasterosteus_aculeatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gasterosteus_aculeatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gasterosteus_aculeatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["69293"]),
        None,
        Some("."),
        Some("ENSGACP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microplitis demolitor nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "69319.XP_008543059.1";
/// let this_library_node_name2 = "69319.XP_008561224.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microplitis_demolitor_node_name(this_library_node_name1));
/// assert!(is_valid_string_microplitis_demolitor_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microplitis_demolitor_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microplitis_demolitor_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["69319"]),
        None,
        Some("."),
        Some("XP_0085"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. VLB120 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "69328.PVLB_00005";
/// let this_library_node_name2 = "69328.PVLB_27762";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_vlb120_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_vlb120_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_vlb120_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_vlb120_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["69328"]),
        None,
        Some("."),
        Some("PVLB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caulobacter henricii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "69395.JQLZ01000001_gene2582";
/// let this_library_node_name2 = "69395.JQLZ01000021_gene4005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caulobacter_henricii_node_name(this_library_node_name1));
/// assert!(is_valid_string_caulobacter_henricii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caulobacter_henricii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caulobacter_henricii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["69395"]),
        None,
        Some("."),
        Some("JQLZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Penicillium oxalicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "69781.S7Z3H6";
/// let this_library_node_name2 = "69781.S8BIG7";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_penicillium_oxalicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_penicillium_oxalicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_penicillium_oxalicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_penicillium_oxalicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["69781"]),
        None,
        Some("."),
        Some("S"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ostreococcus tauri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "70448.A0A090LX27";
/// let this_library_node_name2 = "70448.Q6VRG5";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ostreococcus_tauri_node_name(this_library_node_name1));
/// assert!(is_valid_string_ostreococcus_tauri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ostreococcus_tauri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ostreococcus_tauri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["70448"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrococcus horikoshii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "70601.3256386";
/// let this_library_node_name2 = "70601.4432884";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrococcus_horikoshii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrococcus_horikoshii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrococcus_horikoshii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrococcus_horikoshii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["70601"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eucalyptus grandis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "71139.XP_010023309.1";
/// let this_library_node_name2 = "71139.XP_010070656.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eucalyptus_grandis_node_name(this_library_node_name1));
/// assert!(is_valid_string_eucalyptus_grandis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eucalyptus_grandis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eucalyptus_grandis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["71139"]),
        None,
        Some("."),
        Some("XP_0100"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haemophilus influenzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "71421.HI_0001";
/// let this_library_node_name2 = "71421.HI_1743";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haemophilus_influenzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_haemophilus_influenzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haemophilus_influenzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haemophilus_influenzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["71421"]),
        None,
        Some("."),
        Some("HI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bos mutus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "72004.XP_005886688.1";
/// let this_library_node_name2 = "72004.XP_005912067.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bos_mutus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bos_mutus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bos_mutus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bos_mutus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["72004"]),
        None,
        Some("."),
        Some("XP_005"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphaeroforma arctica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "72019.SARC_00001T0";
/// let this_library_node_name2 = "72019.SARC_18319T0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphaeroforma_arctica_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphaeroforma_arctica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphaeroforma_arctica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphaeroforma_arctica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["72019"]),
        None,
        Some("."),
        Some("SARC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ophiocordyceps sinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "72228.T4ZW57";
/// let this_library_node_name2 = "72228.T5ARC0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ophiocordyceps_sinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ophiocordyceps_sinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ophiocordyceps_sinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ophiocordyceps_sinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["72228"]),
        None,
        Some("."),
        Some("T"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporisorium reilianum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "72558.CBQ67365";
/// let this_library_node_name2 = "72558.CBQ74037";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporisorium_reilianum_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporisorium_reilianum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporisorium_reilianum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporisorium_reilianum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["72558"]),
        None,
        Some("."),
        Some("CBQ"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Boechera stricta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "72658.Bostr.0116s0001.1.p";
/// let this_library_node_name2 = "72658.Bostr.9935s0001.1.p";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_boechera_stricta_node_name(this_library_node_name1));
/// assert!(is_valid_string_boechera_stricta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_boechera_stricta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_boechera_stricta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["72658"]),
        None,
        Some("."),
        Some("Bostr"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eutrema salsugineum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "72664.XP_006389698.1";
/// let this_library_node_name2 = "72664.XP_006419183.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eutrema_salsugineum_node_name(this_library_node_name1));
/// assert!(is_valid_string_eutrema_salsugineum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eutrema_salsugineum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eutrema_salsugineum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["72664"]),
        None,
        Some("."),
        Some("XP_006"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces seoulensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "73044.JNXP01000001_gene4353";
/// let this_library_node_name2 = "73044.JNXP01000075_gene3861";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_seoulensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_seoulensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_seoulensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_seoulensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["73044"]),
        None,
        Some("."),
        Some("JNXP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cordyceps militaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "73501.XP_006665224.1";
/// let this_library_node_name2 = "73501.XP_006674874.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cordyceps_militaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_cordyceps_militaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cordyceps_militaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cordyceps_militaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["73501"]),
        None,
        Some("."),
        Some("XP_0066"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9302 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "74545.EU96_0001";
/// let this_library_node_name2 = "74545.EU96_2055";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9302_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9302_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9302_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9302_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["74545"]),
        None,
        Some("."),
        Some("EU96_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9312 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "74546.PMT9312_0001";
/// let this_library_node_name2 = "74546.PMT9312_1977";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9312_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9312_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9312_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9312_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["74546"]),
        None,
        Some("."),
        Some("PMT9312_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9313 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "74547.PMT_0001";
/// let this_library_node_name2 = "74547.PMT_2926";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9313_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9313_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9313_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9313_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["74547"]),
        None,
        Some("."),
        Some("PMT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiomonas intermedia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "75379.Tint_0001";
/// let this_library_node_name2 = "75379.Tint_3245";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiomonas_intermedia_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiomonas_intermedia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiomonas_intermedia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiomonas_intermedia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["75379"]),
        None,
        Some("."),
        Some("Tint_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aromatoleum aromaticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "76114.c1A100";
/// let this_library_node_name2 = "76114.p2D4";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aromatoleum_aromaticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_aromatoleum_aromaticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aromatoleum_aromaticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aromatoleum_aromaticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["76114"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycetocola saprophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "76636.JOEC01000001_gene100";
/// let this_library_node_name2 = "76636.JOEC01000018_gene75";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycetocola_saprophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycetocola_saprophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycetocola_saprophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycetocola_saprophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["76636"]),
        None,
        Some("."),
        Some("JOEC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas putida GB1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "76869.PputGB1_0001";
/// let this_library_node_name2 = "76869.PputGB1_5444";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_putida_gb1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_putida_gb1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_putida_gb1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_putida_gb1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["76869"]),
        None,
        Some("."),
        Some("PputGB1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leersia perrieri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "77586.LPERR01G00010.1";
/// let this_library_node_name2 = "77586.LPERR12G17140.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leersia_perrieri_node_name(this_library_node_name1));
/// assert!(is_valid_string_leersia_perrieri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leersia_perrieri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leersia_perrieri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["77586"]),
        None,
        Some("."),
        Some("LPERR"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium subtile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "77635.BISU_0001";
/// let this_library_node_name2 = "77635.BISU_3032";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_subtile_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_subtile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_subtile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_subtile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["77635"]),
        None,
        Some("."),
        Some("BISU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthobacter autotrophicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "78245.Xaut_0001";
/// let this_library_node_name2 = "78245.Xaut_5097";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthobacter_autotrophicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthobacter_autotrophicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthobacter_autotrophicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthobacter_autotrophicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["78245"]),
        None,
        Some("."),
        Some("Xaut_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium gallinarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "78344.BIGA_0001";
/// let this_library_node_name2 = "78344.BIGA_4042";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_gallinarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_gallinarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_gallinarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_gallinarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["78344"]),
        None,
        Some("."),
        Some("BIGA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium merycicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "78345.BMERY_0001";
/// let this_library_node_name2 = "78345.BMERY_3013";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_merycicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_merycicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_merycicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_merycicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["78345"]),
        None,
        Some("."),
        Some("BMERY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium ruminantium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "78346.BRUM_0001";
/// let this_library_node_name2 = "78346.BRUM_2011";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_ruminantium_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_ruminantium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_ruminantium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_ruminantium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["78346"]),
        None,
        Some("."),
        Some("BRUM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pectobacterium carotovorum odoriferum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "78398.KS43_00005";
/// let this_library_node_name2 = "78398.KS43_23605";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pectobacterium_carotovorum_odoriferum_node_name(this_library_node_name1));
/// assert!(is_valid_string_pectobacterium_carotovorum_odoriferum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pectobacterium_carotovorum_odoriferum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pectobacterium_carotovorum_odoriferum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["78398"]),
        None,
        Some("."),
        Some("KS43_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myceliophthora thermophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "78579.XP_003658314.1";
/// let this_library_node_name2 = "78579.XP_003667412.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myceliophthora_thermophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_myceliophthora_thermophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myceliophthora_thermophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myceliophthora_thermophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["78579"]),
        None,
        Some("."),
        Some("XP_0036"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mortierella verticillata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "78898.MVEG_00001T0";
/// let this_library_node_name2 = "78898.MVEG_20025T0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mortierella_verticillata_node_name(this_library_node_name1));
/// assert!(is_valid_string_mortierella_verticillata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mortierella_verticillata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mortierella_verticillata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["78898"]),
        None,
        Some("."),
        Some("MVEG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microtus ochrogaster nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "79684.XP_005343172.1";
/// let this_library_node_name2 = "79684.XP_005372592.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microtus_ochrogaster_node_name(this_library_node_name1));
/// assert!(is_valid_string_microtus_ochrogaster_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microtus_ochrogaster_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microtus_ochrogaster_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["79684"]),
        None,
        Some("."),
        Some("XP_0053"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coniophora puteana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "80637.XP_007762351.1";
/// let this_library_node_name2 = "80637.XP_007776108.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coniophora_puteana_node_name(this_library_node_name1));
/// assert!(is_valid_string_coniophora_puteana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coniophora_puteana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coniophora_puteana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["80637"]),
        None,
        Some("."),
        Some("XP_0077"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Colletotrichum higginsianum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "80884.CCF31719";
/// let this_library_node_name2 = "80884.CCF47882";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_colletotrichum_higginsianum_node_name(this_library_node_name1));
/// assert!(is_valid_string_colletotrichum_higginsianum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_colletotrichum_higginsianum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_colletotrichum_higginsianum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["80884"]),
        None,
        Some("."),
        Some("CCF"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Monosiga brevicollis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "81824.XP_001742031.1";
/// let this_library_node_name2 = "81824.XP_001751201.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_monosiga_brevicollis_node_name(this_library_node_name1));
/// assert!(is_valid_string_monosiga_brevicollis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_monosiga_brevicollis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_monosiga_brevicollis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["81824"]),
        None,
        Some("."),
        Some("XP_0017"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capsella rubella nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "81985.XP_006279030.1";
/// let this_library_node_name2 = "81985.XP_006307742.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capsella_rubella_node_name(this_library_node_name1));
/// assert!(is_valid_string_capsella_rubella_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capsella_rubella_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capsella_rubella_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["81985"]),
        None,
        Some("."),
        Some("XP_006"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichosporon asahii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "82508.K1UZW6";
/// let this_library_node_name2 = "82508.K1WYJ5";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichosporon_asahii_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichosporon_asahii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichosporon_asahii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichosporon_asahii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["82508"]),
        None,
        Some("."),
        Some("K1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudanabaena sp. PCC7367 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "82654.Pse7367_0001";
/// let this_library_node_name2 = "82654.Pse7367_R0037";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudanabaena_sp_pcc7367_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudanabaena_sp_pcc7367_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudanabaena_sp_pcc7367_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudanabaena_sp_pcc7367_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["82654"]),
        None,
        Some("."),
        Some("Pse7367_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia grimesii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "82995.CR62_00010";
/// let this_library_node_name2 = "82995.CR62_24745";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_grimesii_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_grimesii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_grimesii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_grimesii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["82995"]),
        None,
        Some("."),
        Some("CR62_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia plymuthica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "82996.sch_00005";
/// let this_library_node_name2 = "82996.sch_25985";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_plymuthica_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_plymuthica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_plymuthica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_plymuthica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["82996"]),
        None,
        Some("."),
        Some("sch_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfitobacter mediterraneus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "83219.PM02_00005";
/// let this_library_node_name2 = "83219.PM02_19745";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfitobacter_mediterraneus_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfitobacter_mediterraneus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfitobacter_mediterraneus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfitobacter_mediterraneus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["83219"]),
        None,
        Some("."),
        Some("PM02_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium tuberculosis H37Rv nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "83332.Rv0001";
/// let this_library_node_name2 = "83332.Rv3924c";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_tuberculosis_h37rv_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_tuberculosis_h37rv_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_tuberculosis_h37rv_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_tuberculosis_h37rv_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["83332"]),
        None,
        Some("."),
        Some("Rv"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudocercospora fijiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "83344.XP_007919624.1";
/// let this_library_node_name2 = "83344.XP_007932689.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudocercospora_fijiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudocercospora_fijiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudocercospora_fijiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudocercospora_fijiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["83344"]),
        None,
        Some("."),
        Some("XP_0079"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium HdN1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "83406.HDN1F_00010";
/// let this_library_node_name2 = "83406.HDN1F_38080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_hdn1_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_hdn1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_hdn1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_hdn1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["83406"]),
        None,
        Some("."),
        Some("HDN1F_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysobacter antibioticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "84531.JMTZ01000001_gene2220";
/// let this_library_node_name2 = "84531.JMTZ01000168_gene751";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysobacter_antibioticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysobacter_antibioticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysobacter_antibioticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysobacter_antibioticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["84531"]),
        None,
        Some("."),
        Some("JMTZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. WH 8102 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "84588.SYNW0001";
/// let this_library_node_name2 = "84588.SYNW2526";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_wh_8102_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_wh_8102_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_wh_8102_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_wh_8102_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["84588"]),
        None,
        Some("."),
        Some("SYNW"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudozyma flocculosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "84751.XP_007875689.1";
/// let this_library_node_name2 = "84751.XP_007882565.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudozyma_flocculosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudozyma_flocculosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudozyma_flocculosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudozyma_flocculosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["84751"]),
        None,
        Some("."),
        Some("XP_0078"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thauera sp. MZ1T nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "85643.Tmz1t_0001";
/// let this_library_node_name2 = "85643.Tmz1t_4089";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thauera_sp_mz1t_node_name(this_library_node_name1));
/// assert!(is_valid_string_thauera_sp_mz1t_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thauera_sp_mz1t_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thauera_sp_mz1t_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["85643"]),
        None,
        Some("."),
        Some("Tmz1t_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citrus clementina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "85681.XP_006419184.1";
/// let this_library_node_name2 = "85681.XP_006453739.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citrus_clementina_node_name(this_library_node_name1));
/// assert!(is_valid_string_citrus_clementina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citrus_clementina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citrus_clementina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["85681"]),
        None,
        Some("."),
        Some("XP_0064"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphaerulina musiva nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "85929.M3AQX7";
/// let this_library_node_name2 = "85929.N1QP24";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphaerulina_musiva_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphaerulina_musiva_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphaerulina_musiva_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphaerulina_musiva_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["85929"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter pylori 26695 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "85962.C694_00005";
/// let this_library_node_name2 = "85962.C694_08250";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_pylori_26695_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_pylori_26695_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_pylori_26695_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_pylori_26695_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["85962"]),
        None,
        Some("."),
        Some("C694_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter pylori J99 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "85963.jhp_0001";
/// let this_library_node_name2 = "85963.jhp_1495";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_pylori_j99_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_pylori_j99_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_pylori_j99_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_pylori_j99_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["85963"]),
        None,
        Some("."),
        Some("jhp_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serpula lacrymans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "85982.XP_007311983.1";
/// let this_library_node_name2 = "85982.XP_007324907.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serpula_lacrymans_node_name(this_library_node_name1));
/// assert!(is_valid_string_serpula_lacrymans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serpula_lacrymans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serpula_lacrymans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["85982"]),
        None,
        Some("."),
        Some("XP_0073"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cladophialophora carrionii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "86049.XP_008721626.1";
/// let this_library_node_name2 = "86049.XP_008731998.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cladophialophora_carrionii_node_name(this_library_node_name1));
/// assert!(is_valid_string_cladophialophora_carrionii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cladophialophora_carrionii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cladophialophora_carrionii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["86049"]),
        None,
        Some("."),
        Some("XP_0087"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING endosymbiont of Acanthamoeba nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "86106.I862_00005";
/// let this_library_node_name2 = "86106.I862_07650";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_endosymbiont_of_acanthamoeba_node_name(this_library_node_name1));
/// assert!(is_valid_string_endosymbiont_of_acanthamoeba_node_name(this_library_node_name2));
/// assert!(!is_valid_string_endosymbiont_of_acanthamoeba_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_endosymbiont_of_acanthamoeba_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["86106"]),
        None,
        Some("."),
        Some("I862_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium pasteurianum BC1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "86416.Clopa_0001";
/// let this_library_node_name2 = "86416.Clopa_4911";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_pasteurianum_bc1_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_pasteurianum_bc1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_pasteurianum_bc1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_pasteurianum_bc1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["86416"]),
        None,
        Some("."),
        Some("Clopa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas tunicata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "87626.PTD2_00005";
/// let this_library_node_name2 = "87626.PTD2_22780";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_tunicata_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_tunicata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_tunicata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_tunicata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["87626"]),
        None,
        Some("."),
        Some("PTD2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selaginella moellendorffii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "88036.ADH10379";
/// let this_library_node_name2 = "88036.EFJ38892";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selaginella_moellendorffii_node_name(this_library_node_name1));
/// assert!(is_valid_string_selaginella_moellendorffii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selaginella_moellendorffii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selaginella_moellendorffii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["88036"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseovarius nubinhibens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "89187.ISM_00005";
/// let this_library_node_name2 = "89187.ISM_17835";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseovarius_nubinhibens_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseovarius_nubinhibens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseovarius_nubinhibens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseovarius_nubinhibens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["89187"]),
        None,
        Some("."),
        Some("ISM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bubalus bubalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "89462.XP_006039578.1";
/// let this_library_node_name2 = "89462.XP_006081063.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bubalus_bubalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bubalus_bubalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bubalus_bubalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bubalus_bubalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["89462"]),
        None,
        Some("."),
        Some("XP_0060"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salmonella enterica Typhimurium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "90371.CY43_00005";
/// let this_library_node_name2 = "90371.CY43_23925";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salmonella_enterica_typhimurium_node_name(this_library_node_name1));
/// assert!(is_valid_string_salmonella_enterica_typhimurium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salmonella_enterica_typhimurium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salmonella_enterica_typhimurium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["90371"]),
        None,
        Some("."),
        Some("CY43_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Camelina sativa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "90675.XP_010412390.1";
/// let this_library_node_name2 = "90675.XP_010518655.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_camelina_sativa_node_name(this_library_node_name1));
/// assert!(is_valid_string_camelina_sativa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_camelina_sativa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_camelina_sativa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["90675"]),
        None,
        Some("."),
        Some("XP_010"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiomicrospira sp. MilosT1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "90813.JQMT01000001_gene1";
/// let this_library_node_name2 = "90813.JQMT01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiomicrospira_sp_milost1_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiomicrospira_sp_milost1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiomicrospira_sp_milost1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiomicrospira_sp_milost1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["90813"]),
        None,
        Some("."),
        Some("JQMT01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiomicrospira sp. MilosT2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "90814.KL370891_gene1";
/// let this_library_node_name2 = "90814.KL370892_gene2337";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiomicrospira_sp_milost2_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiomicrospira_sp_milost2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiomicrospira_sp_milost2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiomicrospira_sp_milost2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["90814"]),
        None,
        Some("."),
        Some("KL37089"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. PCC7335 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "91464.S7335_1";
/// let this_library_node_name2 = "91464.S7335_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_pcc7335_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_pcc7335_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_pcc7335_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_pcc7335_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["91464"]),
        None,
        Some("."),
        Some("S7335_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracaedibacter acanthamoebae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "91604.ID47_00005";
/// let this_library_node_name2 = "91604.ID47_12065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracaedibacter_acanthamoebae_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracaedibacter_acanthamoebae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracaedibacter_acanthamoebae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracaedibacter_acanthamoebae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["91604"]),
        None,
        Some("."),
        Some("ID47_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Metarhizium acridum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "92637.XP_007806341.1";
/// let this_library_node_name2 = "92637.XP_007816189.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_metarhizium_acridum_node_name(this_library_node_name1));
/// assert!(is_valid_string_metarhizium_acridum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_metarhizium_acridum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_metarhizium_acridum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["92637"]),
        None,
        Some("."),
        Some("XP_0078"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9201 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "93057.EU95_0001";
/// let this_library_node_name2 = "93057.EU95_2029";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9201_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9201_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9201_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9201_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["93057"]),
        None,
        Some("."),
        Some("EU95_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9211 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "93059.P9211_00001";
/// let this_library_node_name2 = "93059.P9211_18541";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9211_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9211_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9211_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9211_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["93059"]),
        None,
        Some("."),
        Some("P9211_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9215 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "93060.P9215_00001";
/// let this_library_node_name2 = "93060.P9215_19881";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9215_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9215_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9215_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9215_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["93060"]),
        None,
        Some("."),
        Some("P9215_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pandoraea pnomenusa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "93220.LV28_00010";
/// let this_library_node_name2 = "93220.LV28_24875";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pandoraea_pnomenusa_node_name(this_library_node_name1));
/// assert!(is_valid_string_pandoraea_pnomenusa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pandoraea_pnomenusa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pandoraea_pnomenusa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["93220"]),
        None,
        Some("."),
        Some("LV28_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Setosphaeria turcica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "93612.XP_008020011.1";
/// let this_library_node_name2 = "93612.XP_008031708.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_setosphaeria_turcica_node_name(this_library_node_name1));
/// assert!(is_valid_string_setosphaeria_turcica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_setosphaeria_turcica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_setosphaeria_turcica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["93612"]),
        None,
        Some("."),
        Some("XP_0080"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella sp. ANA3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "94122.Shewana3_0001";
/// let this_library_node_name2 = "94122.Shewana3_4391";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_sp_ana3_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_sp_ana3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_sp_ana3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_sp_ana3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["94122"]),
        None,
        Some("."),
        Some("Shewana3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bordetella petrii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "94624.Bpet0001";
/// let this_library_node_name2 = "94624.ig_1633";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bordetella_petrii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bordetella_petrii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bordetella_petrii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bordetella_petrii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["94624"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. M1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "95619.PM1_0200005";
/// let this_library_node_name2 = "95619.PM1_0230940";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_m1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_m1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_m1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_m1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["95619"]),
        None,
        Some("."),
        Some("PM1_02"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfococcus oleovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "96561.Dole_0001";
/// let this_library_node_name2 = "96561.Dole_3272";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfococcus_oleovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfococcus_oleovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfococcus_oleovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfococcus_oleovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["96561"]),
        None,
        Some("."),
        Some("Dole_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eutypa lata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "97096.XP_007787966.1";
/// let this_library_node_name2 = "97096.XP_007799650.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eutypa_lata_node_name(this_library_node_name1));
/// assert!(is_valid_string_eutypa_lata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eutypa_lata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eutypa_lata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["97096"]),
        None,
        Some("."),
        Some("XP_0077"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus sp. ASF360 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "97137.C821_00001";
/// let this_library_node_name2 = "97137.C821_01988";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_sp_asf360_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_sp_asf360_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_sp_asf360_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_sp_asf360_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["97137"]),
        None,
        Some("."),
        Some("C821_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. ASF356 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "97138.C820_00001";
/// let this_library_node_name2 = "97138.C820_02870";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_asf356_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_asf356_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_asf356_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_asf356_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["97138"]),
        None,
        Some("."),
        Some("C820_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. ASF502 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "97139.C824_00001";
/// let this_library_node_name2 = "97139.C824_06122";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_asf502_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_asf502_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_asf502_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_asf502_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["97139"]),
        None,
        Some("."),
        Some("C824_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fischerella thermalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "98439.AJLL01000001_gene1721";
/// let this_library_node_name2 = "98439.AJLL01000141_gene3698";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fischerella_thermalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_fischerella_thermalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fischerella_thermalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fischerella_thermalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["98439"]),
        None,
        Some("."),
        Some("AJLL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hammondia hammondi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "99158.XP_008881618.1";
/// let this_library_node_name2 = "99158.XP_008889595.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hammondia_hammondi_node_name(this_library_node_name1));
/// assert!(is_valid_string_hammondia_hammondi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hammondia_hammondi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hammondia_hammondi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["99158"]),
        None,
        Some("."),
        Some("XP_00888"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Calothrix sp. PCC7507 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "99598.Cal7507_0001";
/// let this_library_node_name2 = "99598.Cal7507_R0004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_calothrix_sp_pcc7507_node_name(this_library_node_name1));
/// assert!(is_valid_string_calothrix_sp_pcc7507_node_name(this_library_node_name2));
/// assert!(!is_valid_string_calothrix_sp_pcc7507_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_calothrix_sp_pcc7507_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["99598"]),
        None,
        Some("."),
        Some("Cal7507_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces coelicolor nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "100226.SCO0001";
/// let this_library_node_name2 = "100226.SCO7846";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_coelicolor_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_coelicolor_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_coelicolor_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_coelicolor_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["100226"]),
        None,
        Some("."),
        Some("SCO"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wolbachia sp. Ooc nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "100901.wOo_00040";
/// let this_library_node_name2 = "100901.wOo_10770";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wolbachia_sp_ooc_node_name(this_library_node_name1));
/// assert!(is_valid_string_wolbachia_sp_ooc_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wolbachia_sp_ooc_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wolbachia_sp_ooc_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["100901"]),
        None,
        Some("."),
        Some("wOo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusarium pseudograminearum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "101028.EKJ67372";
/// let this_library_node_name2 = "101028.EKJ79819";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusarium_pseudograminearum_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusarium_pseudograminearum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusarium_pseudograminearum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusarium_pseudograminearum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["101028"]),
        None,
        Some("."),
        Some("EKJ"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bipolaris oryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "101162.XP_007682043.1";
/// let this_library_node_name2 = "101162.XP_007694044.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bipolaris_oryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bipolaris_oryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bipolaris_oryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bipolaris_oryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["101162"]),
        None,
        Some("."),
        Some("XP_0076"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus jostii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "101510.RHA1_ro00001";
/// let this_library_node_name2 = "101510.RHA1_ro11334";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_jostii_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_jostii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_jostii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_jostii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["101510"]),
        None,
        Some("."),
        Some("RHA1_ro"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glarea lozoyensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "101852.XP_008075794.1";
/// let this_library_node_name2 = "101852.XP_008088876.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glarea_lozoyensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_glarea_lozoyensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glarea_lozoyensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glarea_lozoyensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["101852"]),
        None,
        Some("."),
        Some("XP_0080"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prunus mume nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "102107.XP_008218142.1";
/// let this_library_node_name2 = "102107.XP_008246562.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prunus_mume_node_name(this_library_node_name1));
/// assert!(is_valid_string_prunus_mume_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prunus_mume_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prunus_mume_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["102107"]),
        None,
        Some("."),
        Some("XP_0082"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xenococcus sp. PCC7305 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "102125.Xen7305DRAFT_00000010";
/// let this_library_node_name2 = "102125.Xen7305DRAFT_00054250";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xenococcus_sp_pcc7305_node_name(this_library_node_name1));
/// assert!(is_valid_string_xenococcus_sp_pcc7305_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xenococcus_sp_pcc7305_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xenococcus_sp_pcc7305_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["102125"]),
        None,
        Some("."),
        Some("Xen7305DRAFT_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptolyngbya sp. PCC7375 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "102129.Lepto7375DRAFT_0001";
/// let this_library_node_name2 = "102129.Lepto7375DRAFT_8452";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptolyngbya_sp_pcc7375_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptolyngbya_sp_pcc7375_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptolyngbya_sp_pcc7375_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptolyngbya_sp_pcc7375_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["102129"]),
        None,
        Some("."),
        Some("Lepto7375DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gloeocapsa sp. PCC73106 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "102232.GLO73106DRAFT_00000010";
/// let this_library_node_name2 = "102232.GLO73106DRAFT_00041580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gloeocapsa_sp_pcc73106_node_name(this_library_node_name1));
/// assert!(is_valid_string_gloeocapsa_sp_pcc73106_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gloeocapsa_sp_pcc73106_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gloeocapsa_sp_pcc73106_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["102232"]),
        None,
        Some("."),
        Some("GLO73106DRAFT_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acromyrmex echinatior nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "103372.F4W3Q6";
/// let this_library_node_name2 = "103372.F6IZV9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acromyrmex_echinatior_node_name(this_library_node_name1));
/// assert!(is_valid_string_acromyrmex_echinatior_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acromyrmex_echinatior_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acromyrmex_echinatior_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["103372"]),
        None,
        Some("."),
        Some("F"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nostoc sp. PCC7120 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "103690.17129650";
/// let this_library_node_name2 = "103690.55420319";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nostoc_sp_pcc7120_node_name(this_library_node_name1));
/// assert!(is_valid_string_nostoc_sp_pcc7120_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nostoc_sp_pcc7120_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nostoc_sp_pcc7120_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["103690"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharothrix syringae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "103733.JNYO01000001_gene100";
/// let this_library_node_name2 = "103733.JNYO01000190_gene6159";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharothrix_syringae_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharothrix_syringae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharothrix_syringae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharothrix_syringae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["103733"]),
        None,
        Some("."),
        Some("JNYO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gloeophyllum trabeum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "104355.XP_007860096.1";
/// let this_library_node_name2 = "104355.XP_007871850.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gloeophyllum_trabeum_node_name(this_library_node_name1));
/// assert!(is_valid_string_gloeophyllum_trabeum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gloeophyllum_trabeum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gloeophyllum_trabeum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["104355"]),
        None,
        Some("."),
        Some("XP_0078"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia sp. ATCC39006 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "104623.Ser39006_00001";
/// let this_library_node_name2 = "104623.Ser39006_04413";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_sp_atcc39006_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_sp_atcc39006_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_sp_atcc39006_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_sp_atcc39006_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["104623"]),
        None,
        Some("."),
        Some("Ser39006_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptacidiphilus neutrinimicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "105420.BBPO01000001_gene1";
/// let this_library_node_name2 = "105420.BBPO01000184_gene7195";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptacidiphilus_neutrinimicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptacidiphilus_neutrinimicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptacidiphilus_neutrinimicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptacidiphilus_neutrinimicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["105420"]),
        None,
        Some("."),
        Some("BBPO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptacidiphilus carbonis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "105422.BBPM01000001_gene4634";
/// let this_library_node_name2 = "105422.BBPM01000139_gene1358";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptacidiphilus_carbonis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptacidiphilus_carbonis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptacidiphilus_carbonis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptacidiphilus_carbonis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["105422"]),
        None,
        Some("."),
        Some("BBPM01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptacidiphilus albus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "105425.BBPL01000001_gene5961";
/// let this_library_node_name2 = "105425.BBPL01000155_gene2842";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptacidiphilus_albus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptacidiphilus_albus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptacidiphilus_albus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptacidiphilus_albus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["105425"]),
        None,
        Some("."),
        Some("BBPL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosococcus watsonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "105559.Nwat_0001";
/// let this_library_node_name2 = "105559.Nwat_3194";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosococcus_watsonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosococcus_watsonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosococcus_watsonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosococcus_watsonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["105559"]),
        None,
        Some("."),
        Some("Nwat_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frankia sp. CcI3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "106370.Francci3_0001";
/// let this_library_node_name2 = "106370.Francci3_4548";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frankia_sp_cci3_node_name(this_library_node_name1));
/// assert!(is_valid_string_frankia_sp_cci3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frankia_sp_cci3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frankia_sp_cci3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["106370"]),
        None,
        Some("."),
        Some("Francci3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Maylandia zebra nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "106582.XP_004537977.1";
/// let this_library_node_name2 = "106582.XP_004576774.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_maylandia_zebra_node_name(this_library_node_name1));
/// assert!(is_valid_string_maylandia_zebra_node_name(this_library_node_name2));
/// assert!(!is_valid_string_maylandia_zebra_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_maylandia_zebra_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["106582"]),
        None,
        Some("."),
        Some("XP_0045"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter bereziniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "106648.BBLJ01000001_gene2081";
/// let this_library_node_name2 = "106648.BBLJ01000132_gene4266";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_bereziniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_bereziniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_bereziniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_bereziniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["106648"]),
        None,
        Some("."),
        Some("BBLJ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylosinus sp. LW3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "107635.AZUO01000001_gene1";
/// let this_library_node_name2 = "107635.AZUO01000005_gene4359";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylosinus_sp_lw3_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylosinus_sp_lw3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylosinus_sp_lw3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylosinus_sp_lw3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["107635"]),
        None,
        Some("."),
        Some("AZUO0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylosinus sp. PW1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "107636.JQNK01000001_gene12";
/// let this_library_node_name2 = "107636.JQNK01000012_gene628";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylosinus_sp_pw1_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylosinus_sp_pw1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylosinus_sp_pw1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylosinus_sp_pw1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["107636"]),
        None,
        Some("."),
        Some("JQNK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Buchnera aphidicola APS nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "107806.10038694";
/// let this_library_node_name2 = "107806.7707816";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_buchnera_aphidicola_aps_node_name(this_library_node_name1));
/// assert!(is_valid_string_buchnera_aphidicola_aps_node_name(this_library_node_name2));
/// assert!(!is_valid_string_buchnera_aphidicola_aps_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_buchnera_aphidicola_aps_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["107806"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myotis brandtii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "109478.XP_005852807.1";
/// let this_library_node_name2 = "109478.XP_005886687.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myotis_brandtii_node_name(this_library_node_name1));
/// assert!(is_valid_string_myotis_brandtii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myotis_brandtii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myotis_brandtii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["109478"]),
        None,
        Some("."),
        Some("XP_0058"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spizellomyces punctatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "109760.SPPG_00001T0";
/// let this_library_node_name2 = "109760.SPPG_12025T0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spizellomyces_punctatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_spizellomyces_punctatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spizellomyces_punctatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spizellomyces_punctatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["109760"]),
        None,
        Some("."),
        Some("SPPG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Batrachochytrium dendrobatidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "109871.XP_006674875.1";
/// let this_library_node_name2 = "109871.XP_006683575.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_batrachochytrium_dendrobatidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_batrachochytrium_dendrobatidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_batrachochytrium_dendrobatidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_batrachochytrium_dendrobatidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["109871"]),
        None,
        Some("."),
        Some("XP_0066"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardioides sp. CF8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "110319.CF8_0001";
/// let this_library_node_name2 = "110319.CF8_4273";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardioides_sp_cf8_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardioides_sp_cf8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardioides_sp_cf8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardioides_sp_cf8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["110319"]),
        None,
        Some("."),
        Some("CF8_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gregarina niphandrodes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "110365.A0A023AUV0";
/// let this_library_node_name2 = "110365.A0A023BE70";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gregarina_niphandrodes_node_name(this_library_node_name1));
/// assert!(is_valid_string_gregarina_niphandrodes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gregarina_niphandrodes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gregarina_niphandrodes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["110365"]),
        None,
        Some("."),
        Some("A0A023"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. CC9605 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "110662.Syncc9605_0001";
/// let this_library_node_name2 = "110662.Syncc9605_2695";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_cc9605_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_cc9605_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_cc9605_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_cc9605_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["110662"]),
        None,
        Some("."),
        Some("Syncc9605_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. CC9616 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "110663.KI911558_gene1";
/// let this_library_node_name2 = "110663.KI911558_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_cc9616_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_cc9616_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_cc9616_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_cc9616_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["110663"]),
        None,
        Some("."),
        Some("KI911558_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas gulae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "111105.HR09_00010";
/// let this_library_node_name2 = "111105.HR09_11120";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_gulae_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_gulae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_gulae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_gulae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["111105"]),
        None,
        Some("."),
        Some("HR09_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stanieria cyanosphaera nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "111780.Sta7437_0001";
/// let this_library_node_name2 = "111780.Sta7437_R0045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stanieria_cyanosphaera_node_name(this_library_node_name1));
/// assert!(is_valid_string_stanieria_cyanosphaera_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stanieria_cyanosphaera_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stanieria_cyanosphaera_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["111780"]),
        None,
        Some("."),
        Some("Sta7437_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptolyngbya sp. PCC7376 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "111781.Lepto7376_0001";
/// let this_library_node_name2 = "111781.Lepto7376_R0021";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptolyngbya_sp_pcc7376_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptolyngbya_sp_pcc7376_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptolyngbya_sp_pcc7376_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptolyngbya_sp_pcc7376_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["111781"]),
        None,
        Some("."),
        Some("Lepto7376_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saprolegnia diclina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "112098.XP_008603684.1";
/// let this_library_node_name2 = "112098.XP_008621912.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saprolegnia_diclina_node_name(this_library_node_name1));
/// assert!(is_valid_string_saprolegnia_diclina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saprolegnia_diclina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saprolegnia_diclina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["112098"]),
        None,
        Some("."),
        Some("XP_0086"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geminocystis herdmanii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "113355.CM001775_gene1";
/// let this_library_node_name2 = "113355.CM001775_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geminocystis_herdmanii_node_name(this_library_node_name1));
/// assert!(is_valid_string_geminocystis_herdmanii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geminocystis_herdmanii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geminocystis_herdmanii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["113355"]),
        None,
        Some("."),
        Some("CM001775_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. Tv2a2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "113395.AXAI01000001_gene2764";
/// let this_library_node_name2 = "113395.AXAI01000087_gene3445";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_tv2a2_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_tv2a2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_tv2a2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_tv2a2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["113395"]),
        None,
        Some("."),
        Some("AXAI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tetrapisispora phaffii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "113608.XP_003683525.1";
/// let this_library_node_name2 = "113608.XP_003688777.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tetrapisispora_phaffii_node_name(this_library_node_name1));
/// assert!(is_valid_string_tetrapisispora_phaffii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tetrapisispora_phaffii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tetrapisispora_phaffii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["113608"]),
        None,
        Some("."),
        Some("XP_00368"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. ORS278 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "114615.BRADO0001";
/// let this_library_node_name2 = "114615.BRADO7143";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_ors278_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_ors278_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_ors278_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_ors278_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["114615"]),
        None,
        Some("."),
        Some("BRADO"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pythium iwayamai nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "115417.EPrPW00000013083";
/// let this_library_node_name2 = "115417.EPrPW00000028337";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pythium_iwayamai_node_name(this_library_node_name1));
/// assert!(is_valid_string_pythium_iwayamai_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pythium_iwayamai_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pythium_iwayamai_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["115417"]),
        None,
        Some("."),
        Some("EPrPW000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydophila pneumoniae AR39 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "115711.CP_0001";
/// let this_library_node_name2 = "115711.CP_1128";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydophila_pneumoniae_ar39_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydophila_pneumoniae_ar39_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydophila_pneumoniae_ar39_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydophila_pneumoniae_ar39_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["115711"]),
        None,
        Some("."),
        Some("CP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydophila pneumoniae CWL029 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "115713.CPn_0001";
/// let this_library_node_name2 = "115713.CPn_1073";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydophila_pneumoniae_cwl029_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydophila_pneumoniae_cwl029_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydophila_pneumoniae_cwl029_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydophila_pneumoniae_cwl029_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["115713"]),
        None,
        Some("."),
        Some("CPn_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusarium verticillioides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "117187.FVEG_00001T0";
/// let this_library_node_name2 = "117187.FVEG_14183T0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusarium_verticillioides_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusarium_verticillioides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusarium_verticillioides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusarium_verticillioides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["117187"]),
        None,
        Some("."),
        Some("FVEG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chrysiogenes arsenatis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "118005.AWNK01000001_gene1784";
/// let this_library_node_name2 = "118005.AWNK01000023_gene920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chrysiogenes_arsenatis_node_name(this_library_node_name1));
/// assert!(is_valid_string_chrysiogenes_arsenatis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chrysiogenes_arsenatis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chrysiogenes_arsenatis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["118005"]),
        None,
        Some("."),
        Some("AWNK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pleurocapsa sp. PCC7319 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "118161.KB235916_gene6593";
/// let this_library_node_name2 = "118161.KB235925_gene6490";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pleurocapsa_sp_pcc7319_node_name(this_library_node_name1));
/// assert!(is_valid_string_pleurocapsa_sp_pcc7319_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pleurocapsa_sp_pcc7319_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pleurocapsa_sp_pcc7319_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["118161"]),
        None,
        Some("."),
        Some("KB2359"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pleurocapsa sp. PCC7327 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "118163.Ple7327_0001";
/// let this_library_node_name2 = "118163.Ple7327_4671";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pleurocapsa_sp_pcc7327_node_name(this_library_node_name1));
/// assert!(is_valid_string_pleurocapsa_sp_pcc7327_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pleurocapsa_sp_pcc7327_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pleurocapsa_sp_pcc7327_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["118163"]),
        None,
        Some("."),
        Some("Ple7327_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nodosilinea nodulosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "118166.JH976537_gene1";
/// let this_library_node_name2 = "118166.JH976538_gene5533";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nodosilinea_nodulosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_nodosilinea_nodulosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nodosilinea_nodulosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nodosilinea_nodulosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["118166"]),
        None,
        Some("."),
        Some("JH97653"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coleofasciculus chthonoplastes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "118168.MC7420_1";
/// let this_library_node_name2 = "118168.MC7420_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coleofasciculus_chthonoplastes_node_name(this_library_node_name1));
/// assert!(is_valid_string_coleofasciculus_chthonoplastes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coleofasciculus_chthonoplastes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coleofasciculus_chthonoplastes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["118168"]),
        None,
        Some("."),
        Some("MC7420_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudanabaena sp. PCC6802 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "118173.KB235910_gene4326";
/// let this_library_node_name2 = "118173.KB235915_gene4";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudanabaena_sp_pcc6802_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudanabaena_sp_pcc6802_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudanabaena_sp_pcc6802_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudanabaena_sp_pcc6802_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["118173"]),
        None,
        Some("."),
        Some("KB23591"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lipotes vexillifer nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "118797.XP_007445584.1";
/// let this_library_node_name2 = "118797.XP_007472471.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lipotes_vexillifer_node_name(this_library_node_name1));
/// assert!(is_valid_string_lipotes_vexillifer_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lipotes_vexillifer_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lipotes_vexillifer_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["118797"]),
        None,
        Some("."),
        Some("XP_0074"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ustilago hordei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "120017.I2FLU5";
/// let this_library_node_name2 = "120017.L7N6F6";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ustilago_hordei_node_name(this_library_node_name1));
/// assert!(is_valid_string_ustilago_hordei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ustilago_hordei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ustilago_hordei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["120017"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pediculus humanus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "121225.PHUM000210-PA";
/// let this_library_node_name2 = "121225.PHUM627378-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pediculus_humanus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pediculus_humanus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pediculus_humanus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pediculus_humanus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["121225"]),
        None,
        Some("."),
        Some("PHUM"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccidioides brasiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "121759.XP_010755650.1";
/// let this_library_node_name2 = "121759.XP_010764039.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccidioides_brasiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccidioides_brasiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccidioides_brasiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccidioides_brasiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["121759"]),
        None,
        Some("."),
        Some("XP_0107"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Persephonella marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "123214.PERMA_0001";
/// let this_library_node_name2 = "123214.PERMA_A0070";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_persephonella_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_persephonella_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_persephonella_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_persephonella_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["123214"]),
        None,
        Some("."),
        Some("PERMA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bordetella trematum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "123899.JPQP01000001_gene1516";
/// let this_library_node_name2 = "123899.JPQP01000023_gene3263";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bordetella_trematum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bordetella_trematum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bordetella_trematum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bordetella_trematum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["123899"]),
        None,
        Some("."),
        Some("JPQP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Strigamia maritima nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "126957.SMAR000001-PA";
/// let this_library_node_name2 = "126957.SMAR015788-PA";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_strigamia_maritima_node_name(this_library_node_name1));
/// assert!(is_valid_string_strigamia_maritima_node_name(this_library_node_name2));
/// assert!(!is_valid_string_strigamia_maritima_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_strigamia_maritima_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["126957"]),
        None,
        Some("."),
        Some("SMAR0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nipponia nippon nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "128390.XP_009458743.1";
/// let this_library_node_name2 = "128390.XP_009475818.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nipponia_nippon_node_name(this_library_node_name1));
/// assert!(is_valid_string_nipponia_nippon_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nipponia_nippon_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nipponia_nippon_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["128390"]),
        None,
        Some("."),
        Some("XP_0094"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Galdieria sulphuraria nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "130081.XP_005674712.1";
/// let this_library_node_name2 = "130081.XP_005709410.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_galdieria_sulphuraria_node_name(this_library_node_name1));
/// assert!(is_valid_string_galdieria_sulphuraria_node_name(this_library_node_name2));
/// assert!(!is_valid_string_galdieria_sulphuraria_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_galdieria_sulphuraria_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["130081"]),
        None,
        Some("."),
        Some("XP_005"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bombus impatiens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "132113.XP_003484387.1";
/// let this_library_node_name2 = "132113.XP_003494951.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bombus_impatiens_node_name(this_library_node_name1));
/// assert!(is_valid_string_bombus_impatiens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bombus_impatiens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bombus_impatiens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["132113"]),
        None,
        Some("."),
        Some("XP_0034"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pteropus vampyrus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "132908.ENSPVAP00000000002";
/// let this_library_node_name2 = "132908.ENSPVAP00000017101";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pteropus_vampyrus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pteropus_vampyrus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pteropus_vampyrus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pteropus_vampyrus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["132908"]),
        None,
        Some("."),
        Some("ENSPVAP000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinoplanes sp. SE50110 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "134676.ACPL_1000";
/// let this_library_node_name2 = "134676.ACPL_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinoplanes_sp_se50110_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinoplanes_sp_se50110_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinoplanes_sp_se50110_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinoplanes_sp_se50110_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["134676"]),
        None,
        Some("."),
        Some("ACPL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caenorhabditis brenneri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "135651.CBN00001";
/// let this_library_node_name2 = "135651.CBN32864";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caenorhabditis_brenneri_node_name(this_library_node_name1));
/// assert!(is_valid_string_caenorhabditis_brenneri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caenorhabditis_brenneri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caenorhabditis_brenneri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["135651"]),
        None,
        Some("."),
        Some("CBN"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zootermopsis nevadensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "136037.KDQ65242";
/// let this_library_node_name2 = "136037.KDR24549";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zootermopsis_nevadensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_zootermopsis_nevadensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zootermopsis_nevadensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zootermopsis_nevadensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["136037"]),
        None,
        Some("."),
        Some("KD"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kocuria polaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "136273.GY22_00005";
/// let this_library_node_name2 = "136273.GY22_17310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kocuria_polaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_kocuria_polaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kocuria_polaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kocuria_polaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["136273"]),
        None,
        Some("."),
        Some("GY22_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylosinus sp. LW4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "136993.KB900626_gene1000";
/// let this_library_node_name2 = "136993.KB900628_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylosinus_sp_lw4_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylosinus_sp_lw4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylosinus_sp_lw4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylosinus_sp_lw4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["136993"]),
        None,
        Some("."),
        Some("KB90062"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfitobacterium hafniense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "138119.DSY0001";
/// let this_library_node_name2 = "138119.DSY5060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfitobacterium_hafniense_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfitobacterium_hafniense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfitobacterium_hafniense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfitobacterium_hafniense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["138119"]),
        None,
        Some("."),
        Some("DSY"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nectria haematococca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "140110.NechaP100001";
/// let this_library_node_name2 = "140110.NechaP99994";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nectria_haematococca_node_name(this_library_node_name1));
/// assert!(is_valid_string_nectria_haematococca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nectria_haematococca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nectria_haematococca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["140110"]),
        None,
        Some("."),
        Some("NechaP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnobacterium bovis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "140626.JHWB01000001_gene2604";
/// let this_library_node_name2 = "140626.JHWB01000022_gene2143";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnobacterium_bovis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnobacterium_bovis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnobacterium_bovis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnobacterium_bovis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["140626"]),
        None,
        Some("."),
        Some("JHWB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zobellia uliginosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "143224.JQMD01000001_gene1";
/// let this_library_node_name2 = "143224.JQMD01000002_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zobellia_uliginosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_zobellia_uliginosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zobellia_uliginosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zobellia_uliginosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["143224"]),
        None,
        Some("."),
        Some("JQMD0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stegastes partitus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "144197.XP_008273682.1";
/// let this_library_node_name2 = "144197.XP_008305276.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stegastes_partitus_node_name(this_library_node_name1));
/// assert!(is_valid_string_stegastes_partitus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stegastes_partitus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stegastes_partitus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["144197"]),
        None,
        Some("."),
        Some("XP_008"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus AS9601 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "146891.A9601_00001";
/// let this_library_node_name2 = "146891.A9601_19251";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_as9601_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_as9601_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_as9601_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_as9601_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["146891"]),
        None,
        Some("."),
        Some("A9601_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces griseofuscus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "146922.JOFU01000001_gene252";
/// let this_library_node_name2 = "146922.JOFU01000244_gene3180";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_griseofuscus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_griseofuscus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_griseofuscus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_griseofuscus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["146922"]),
        None,
        Some("."),
        Some("JOFU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Magnaporthiopsis poae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "148304.MAPG_00002T0";
/// let this_library_node_name2 = "148304.MAPG_12169T0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_magnaporthiopsis_poae_node_name(this_library_node_name1));
/// assert!(is_valid_string_magnaporthiopsis_poae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_magnaporthiopsis_poae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_magnaporthiopsis_poae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["148304"]),
        None,
        Some("."),
        Some("MAPG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus kunkeei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "148814.JI66_00005";
/// let this_library_node_name2 = "148814.JI66_07820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_kunkeei_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_kunkeei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_kunkeei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_kunkeei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["148814"]),
        None,
        Some("."),
        Some("JI66_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wallemia sebi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "148960.XP_006955634.1";
/// let this_library_node_name2 = "148960.XP_006960910.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wallemia_sebi_node_name(this_library_node_name1));
/// assert!(is_valid_string_wallemia_sebi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wallemia_sebi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wallemia_sebi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["148960"]),
        None,
        Some("."),
        Some("XP_0069"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kozakia baliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "153496.JNAB01000001_gene718";
/// let this_library_node_name2 = "153496.JNAB01000106_gene357";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kozakia_baliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_kozakia_baliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kozakia_baliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kozakia_baliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["153496"]),
        None,
        Some("."),
        Some("JNAB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporocytophaga myxococcoides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "153721.MYP_1";
/// let this_library_node_name2 = "153721.MYP_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporocytophaga_myxococcoides_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporocytophaga_myxococcoides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporocytophaga_myxococcoides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporocytophaga_myxococcoides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["153721"]),
        None,
        Some("."),
        Some("MYP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosomonas sp. AL212 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "153948.NAL212_0001";
/// let this_library_node_name2 = "153948.NAL212_3195";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosomonas_sp_al212_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosomonas_sp_al212_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosomonas_sp_al212_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosomonas_sp_al212_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["153948"]),
        None,
        Some("."),
        Some("NAL212_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gallibacterium genomosp. nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "155515.JP36_00010";
/// let this_library_node_name2 = "155515.JP36_11380";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gallibacterium_genomosp_node_name(this_library_node_name1));
/// assert!(is_valid_string_gallibacterium_genomosp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gallibacterium_genomosp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gallibacterium_genomosp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["155515"]),
        None,
        Some("."),
        Some("JP36_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia coli O157H7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "155864.EDL933_0001";
/// let this_library_node_name2 = "155864.EDL933_p0097";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_coli_o157h7_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_coli_o157h7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_coli_o157h7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_coli_o157h7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["155864"]),
        None,
        Some("."),
        Some("EDL933_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alteromonadales bacterium TW7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "156578.ATW7_00005";
/// let this_library_node_name2 = "156578.ATW7_19073";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alteromonadales_bacterium_tw7_node_name(this_library_node_name1));
/// assert!(is_valid_string_alteromonadales_bacterium_tw7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alteromonadales_bacterium_tw7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alteromonadales_bacterium_tw7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["156578"]),
        None,
        Some("."),
        Some("ATW7_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Magnetococcus marinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "156889.Mmc1_0001";
/// let this_library_node_name2 = "156889.Mmc1_3760";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_magnetococcus_marinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_magnetococcus_marinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_magnetococcus_marinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_magnetococcus_marinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["156889"]),
        None,
        Some("."),
        Some("Mmc1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium imitans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "156978.CIMIT_00005";
/// let this_library_node_name2 = "156978.CIMIT_12170";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_imitans_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_imitans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_imitans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_imitans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["156978"]),
        None,
        Some("."),
        Some("CIMIT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aphanomyces invadans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "157072.XP_008860798.1";
/// let this_library_node_name2 = "157072.XP_008881613.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aphanomyces_invadans_node_name(this_library_node_name1));
/// assert!(is_valid_string_aphanomyces_invadans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aphanomyces_invadans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aphanomyces_invadans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["157072"]),
        None,
        Some("."),
        Some("XP_0088"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas cremoricolorata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "157783.LK03_00025";
/// let this_library_node_name2 = "157783.LK03_21930";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_cremoricolorata_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_cremoricolorata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_cremoricolorata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_cremoricolorata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["157783"]),
        None,
        Some("."),
        Some("LK03_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphaerochaeta globosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "158189.SpiBuddy_0001";
/// let this_library_node_name2 = "158189.SpiBuddy_3058";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphaerochaeta_globosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphaerochaeta_globosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphaerochaeta_globosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphaerochaeta_globosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["158189"]),
        None,
        Some("."),
        Some("SpiBuddy_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphaerochaeta pleomorpha nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "158190.SpiGrapes_0001";
/// let this_library_node_name2 = "158190.SpiGrapes_3283";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphaerochaeta_pleomorpha_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphaerochaeta_pleomorpha_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphaerochaeta_pleomorpha_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphaerochaeta_pleomorpha_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["158190"]),
        None,
        Some("."),
        Some("SpiGrapes_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novosphingobium resinovorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "158500.BV97_00001";
/// let this_library_node_name2 = "158500.BV97_05793";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novosphingobium_resinovorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_novosphingobium_resinovorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novosphingobium_resinovorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novosphingobium_resinovorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["158500"]),
        None,
        Some("."),
        Some("BV97_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium scardovii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "158787.BSCA_0001";
/// let this_library_node_name2 = "158787.BSCA_3776";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_scardovii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_scardovii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_scardovii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_scardovii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["158787"]),
        None,
        Some("."),
        Some("BSCA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cedecea neteri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "158822.LH89_00010";
/// let this_library_node_name2 = "158822.LH89_22330";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cedecea_neteri_node_name(this_library_node_name1));
/// assert!(is_valid_string_cedecea_neteri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cedecea_neteri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cedecea_neteri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["158822"]),
        None,
        Some("."),
        Some("LH89_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dechloromonas aromatica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "159087.Daro_0001";
/// let this_library_node_name2 = "159087.Daro_4204";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dechloromonas_aromatica_node_name(this_library_node_name1));
/// assert!(is_valid_string_dechloromonas_aromatica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dechloromonas_aromatica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dechloromonas_aromatica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["159087"]),
        None,
        Some("."),
        Some("Daro_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sacchari nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "159450.NH14_00005";
/// let this_library_node_name2 = "159450.NH14_32220";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sacchari_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sacchari_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sacchari_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sacchari_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["159450"]),
        None,
        Some("."),
        Some("NH14_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thalassiosira oceanica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "159749.E7BWC0";
/// let this_library_node_name2 = "159749.K3W4K8";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thalassiosira_oceanica_node_name(this_library_node_name1));
/// assert!(is_valid_string_thalassiosira_oceanica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thalassiosira_oceanica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thalassiosira_oceanica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["159749"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas putida KT2440 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "160488.PP_0001";
/// let this_library_node_name2 = "160488.PP_5420";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_putida_kt2440_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_putida_kt2440_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_putida_kt2440_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_putida_kt2440_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["160488"]),
        None,
        Some("."),
        Some("PP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xylella fastidiosa 9a5c nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "160492.XF_0001";
/// let this_library_node_name2 = "160492.XF_a0065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xylella_fastidiosa_9a5c_node_name(this_library_node_name1));
/// assert!(is_valid_string_xylella_fastidiosa_9a5c_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xylella_fastidiosa_9a5c_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xylella_fastidiosa_9a5c_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["160492"]),
        None,
        Some("."),
        Some("XF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus borealis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "160799.PBOR_00010";
/// let this_library_node_name2 = "160799.PBOR_36180";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_borealis_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_borealis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_borealis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_borealis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["160799"]),
        None,
        Some("."),
        Some("PBOR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Auricularia delicata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "160860.XP_007336186.1";
/// let this_library_node_name2 = "160860.XP_007359740.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_auricularia_delicata_node_name(this_library_node_name1));
/// assert!(is_valid_string_auricularia_delicata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_auricularia_delicata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_auricularia_delicata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["160860"]),
        None,
        Some("."),
        Some("XP_0073"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermodesulfobacterium hydrogeniphilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "161156.JQKW01000001_gene1402";
/// let this_library_node_name2 = "161156.JQKW01000014_gene267";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermodesulfobacterium_hydrogeniphilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermodesulfobacterium_hydrogeniphilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermodesulfobacterium_hydrogeniphilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermodesulfobacterium_hydrogeniphilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["161156"]),
        None,
        Some("."),
        Some("JQKW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erythrobacter sp. SD21 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "161528.ED21_17462";
/// let this_library_node_name2 = "161528.ED21_32252";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erythrobacter_sp_sd21_node_name(this_library_node_name1));
/// assert!(is_valid_string_erythrobacter_sp_sd21_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erythrobacter_sp_sd21_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erythrobacter_sp_sd21_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["161528"]),
        None,
        Some("."),
        Some("ED21_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Beta vulgaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "161934.XP_010665502.1";
/// let this_library_node_name2 = "161934.XP_010696643.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_beta_vulgaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_beta_vulgaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_beta_vulgaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_beta_vulgaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["161934"]),
        None,
        Some("."),
        Some("XP_0106"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aspergillus nidulans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "162425.CADANIAP00000001";
/// let this_library_node_name2 = "162425.CADANIAP00010534";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aspergillus_nidulans_node_name(this_library_node_name1));
/// assert!(is_valid_string_aspergillus_nidulans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aspergillus_nidulans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aspergillus_nidulans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["162425"]),
        None,
        Some("."),
        Some("CADANIAP000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wolbachia sp. Dme nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "163164.WD_0001";
/// let this_library_node_name2 = "163164.WD_1322";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wolbachia_sp_dme_node_name(this_library_node_name1));
/// assert!(is_valid_string_wolbachia_sp_dme_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wolbachia_sp_dme_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wolbachia_sp_dme_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["163164"]),
        None,
        Some("."),
        Some("WD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anabaena sp. PCC7108 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "163908.KB235895_gene4977";
/// let this_library_node_name2 = "163908.KB235897_gene6";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anabaena_sp_pcc7108_node_name(this_library_node_name1));
/// assert!(is_valid_string_anabaena_sp_pcc7108_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anabaena_sp_pcc7108_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anabaena_sp_pcc7108_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["163908"]),
        None,
        Some("."),
        Some("KB23589"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytophthora ramorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "164328.Phyra38546";
/// let this_library_node_name2 = "164328.Phyra97195";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytophthora_ramorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytophthora_ramorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytophthora_ramorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytophthora_ramorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["164328"]),
        None,
        Some("."),
        Some("Phyra"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium sp. JLS nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "164757.Mjls_0001";
/// let this_library_node_name2 = "164757.Mjls_5789";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_sp_jls_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_sp_jls_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_sp_jls_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_sp_jls_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["164757"]),
        None,
        Some("."),
        Some("Mjls_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. WH 8109 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "166314.Syncc8109_0001";
/// let this_library_node_name2 = "166314.Syncc8109_2764";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_wh_8109_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_wh_8109_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_wh_8109_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_wh_8109_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["166314"]),
        None,
        Some("."),
        Some("Syncc8109_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. WH 8016 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "166318.Syn8016DRAFT_0001";
/// let this_library_node_name2 = "166318.Syn8016DRAFT_2997";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_wh_8016_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_wh_8016_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_wh_8016_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_wh_8016_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["166318"]),
        None,
        Some("."),
        Some("Syn8016DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus CCMP1375 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "167539.Pro_0001";
/// let this_library_node_name2 = "167539.Pro_1885";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_ccmp1375_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_ccmp1375_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_ccmp1375_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_ccmp1375_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["167539"]),
        None,
        Some("."),
        Some("Pro_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9515 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "167542.P9515_00001";
/// let this_library_node_name2 = "167542.P9515_19071";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9515_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9515_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9515_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9515_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["167542"]),
        None,
        Some("."),
        Some("P9515_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9301 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "167546.P9301_00001";
/// let this_library_node_name2 = "167546.P9301_19061";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9301_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9301_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9301_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9301_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["167546"]),
        None,
        Some("."),
        Some("P9301_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9314 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "167548.EU98_0001";
/// let this_library_node_name2 = "167548.EU98_2029";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9314_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9314_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9314_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9314_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["167548"]),
        None,
        Some("."),
        Some("EU98_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus MIT9322 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "167550.EV00_0001";
/// let this_library_node_name2 = "167550.EV00_1998";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_mit9322_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_mit9322_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_mit9322_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_mit9322_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["167550"]),
        None,
        Some("."),
        Some("EV00_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus marinus NATL1A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "167555.NATL1_00001";
/// let this_library_node_name2 = "167555.NATL1_22001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_marinus_natl1a_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_marinus_natl1a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_marinus_natl1a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_marinus_natl1a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["167555"]),
        None,
        Some("."),
        Some("NATL1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeria monocytogenes EGDe nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "169963.lmo0001";
/// let this_library_node_name2 = "169963.lmo2857";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeria_monocytogenes_egde_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeria_monocytogenes_egde_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeria_monocytogenes_egde_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeria_monocytogenes_egde_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["169963"]),
        None,
        Some("."),
        Some("lmo"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus pneumoniae TIGR4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "170187.SP_0001";
/// let this_library_node_name2 = "170187.SP_2241";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_pneumoniae_tigr4_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_pneumoniae_tigr4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_pneumoniae_tigr4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_pneumoniae_tigr4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["170187"]),
        None,
        Some("."),
        Some("SP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus pneumoniae R6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "171101.spr0001";
/// let this_library_node_name2 = "171101.spr2046";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_pneumoniae_r6_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_pneumoniae_r6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_pneumoniae_r6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_pneumoniae_r6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["171101"]),
        None,
        Some("."),
        Some("spr"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanobacillus picturae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "171693.BN988_00002";
/// let this_library_node_name2 = "171693.BN988_03823";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanobacillus_picturae_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanobacillus_picturae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanobacillus_picturae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanobacillus_picturae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["171693"]),
        None,
        Some("."),
        Some("BN988_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Elizabethkingia miricola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "172045.KS04_00005";
/// let this_library_node_name2 = "172045.KS04_22250";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_elizabethkingia_miricola_node_name(this_library_node_name1));
/// assert!(is_valid_string_elizabethkingia_miricola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_elizabethkingia_miricola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_elizabethkingia_miricola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["172045"]),
        None,
        Some("."),
        Some("KS04_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. thb2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "172088.AUGA01000001_gene6226";
/// let this_library_node_name2 = "172088.AUGA01000272_gene6976";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_thb2_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_thb2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_thb2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_thb2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["172088"]),
        None,
        Some("."),
        Some("AUGA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "176090.SSIN_0001";
/// let this_library_node_name2 = "176090.SSIN_2042";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["176090"]),
        None,
        Some("."),
        Some("SSIN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Beauveria bassiana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "176275.XP_008593320.1";
/// let this_library_node_name2 = "176275.XP_008603683.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_beauveria_bassiana_node_name(this_library_node_name1));
/// assert!(is_valid_string_beauveria_bassiana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_beauveria_bassiana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_beauveria_bassiana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["176275"]),
        None,
        Some("."),
        Some("XP_008"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus epidermidis RP62A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "176279.SERP0001";
/// let this_library_node_name2 = "176279.SERP2553";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_epidermidis_rp62a_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_epidermidis_rp62a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_epidermidis_rp62a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_epidermidis_rp62a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["176279"]),
        None,
        Some("."),
        Some("SERP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus epidermidis ATCC12228 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "176280.SE_0001";
/// let this_library_node_name2 = "176280.SE_p611";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_epidermidis_atcc12228_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_epidermidis_atcc12228_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_epidermidis_atcc12228_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_epidermidis_atcc12228_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["176280"]),
        None,
        Some("."),
        Some("SE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agrobacterium fabrum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "176299.Atu0001";
/// let this_library_node_name2 = "176299.Atu8206";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agrobacterium_fabrum_node_name(this_library_node_name1));
/// assert!(is_valid_string_agrobacterium_fabrum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agrobacterium_fabrum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agrobacterium_fabrum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["176299"]),
        None,
        Some("."),
        Some("Atu"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Python bivittatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "176946.XP_007419848.1";
/// let this_library_node_name2 = "176946.XP_007445583.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_python_bivittatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_python_bivittatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_python_bivittatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_python_bivittatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["176946"]),
        None,
        Some("."),
        Some("XP_0074"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Francisella tularensis SCHUS4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "177416.FTT_0001";
/// let this_library_node_name2 = "177416.FTT_1804c";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_francisella_tularensis_schus4_node_name(this_library_node_name1));
/// assert!(is_valid_string_francisella_tularensis_schus4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_francisella_tularensis_schus4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_francisella_tularensis_schus4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["177416"]),
        None,
        Some("."),
        Some("FTT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfobacterium autotrophicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "177437.HRM2_00010";
/// let this_library_node_name2 = "177437.HRM2_p00760";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfobacterium_autotrophicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfobacterium_autotrophicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfobacterium_autotrophicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfobacterium_autotrophicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["177437"]),
        None,
        Some("."),
        Some("HRM2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotalea psychrophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "177439.DP0001";
/// let this_library_node_name2 = "177439.DPPB99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotalea_psychrophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotalea_psychrophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotalea_psychrophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotalea_psychrophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["177439"]),
        None,
        Some("."),
        Some("DP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrobaculum aerophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "178306.PAE0001";
/// let this_library_node_name2 = "178306.PAE3689";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrobaculum_aerophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrobaculum_aerophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrobaculum_aerophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrobaculum_aerophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["178306"]),
        None,
        Some("."),
        Some("PAE"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetobacter malorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "178901.AmDm5_0001";
/// let this_library_node_name2 = "178901.AmDm5_3148";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetobacter_malorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetobacter_malorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetobacter_malorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetobacter_malorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["178901"]),
        None,
        Some("."),
        Some("AmDm5_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oscillatoria nigroviridis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "179408.Osc7112_0001";
/// let this_library_node_name2 = "179408.Osc7112_6921";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oscillatoria_nigroviridis_node_name(this_library_node_name1));
/// assert!(is_valid_string_oscillatoria_nigroviridis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oscillatoria_nigroviridis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oscillatoria_nigroviridis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["179408"]),
        None,
        Some("."),
        Some("Osc7112_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanobium sp. PCC7001 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "180281.CPCC7001_1";
/// let this_library_node_name2 = "180281.CPCC7001_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanobium_sp_pcc7001_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanobium_sp_pcc7001_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanobium_sp_pcc7001_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanobium_sp_pcc7001_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["180281"]),
        None,
        Some("."),
        Some("CPCC7001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Robinsoniella peoriensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "180332.JTGN01000001_gene4576";
/// let this_library_node_name2 = "180332.JTGN01000032_gene1175";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_robinsoniella_peoriensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_robinsoniella_peoriensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_robinsoniella_peoriensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_robinsoniella_peoriensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["180332"]),
        None,
        Some("."),
        Some("JTGN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudopodoces humilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "181119.XP_005516203.1";
/// let this_library_node_name2 = "181119.XP_005534763.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudopodoces_humilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudopodoces_humilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudopodoces_humilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudopodoces_humilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["181119"]),
        None,
        Some("."),
        Some("XP_0055"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydophila pneumoniae TW183 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "182082.CpB0001";
/// let this_library_node_name2 = "182082.CpB1118";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydophila_pneumoniae_tw183_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydophila_pneumoniae_tw183_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydophila_pneumoniae_tw183_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydophila_pneumoniae_tw183_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["182082"]),
        None,
        Some("."),
        Some("CpB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter cetorum MIT007128 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "182217.HCW_00005";
/// let this_library_node_name2 = "182217.HCW_08835";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_cetorum_mit007128_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_cetorum_mit007128_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_cetorum_mit007128_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_cetorum_mit007128_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["182217"]),
        None,
        Some("."),
        Some("HCW_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chrysochloris asiatica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "185453.XP_006830672.1";
/// let this_library_node_name2 = "185453.XP_006878488.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chrysochloris_asiatica_node_name(this_library_node_name1));
/// assert!(is_valid_string_chrysochloris_asiatica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chrysochloris_asiatica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chrysochloris_asiatica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["185453"]),
        None,
        Some("."),
        Some("XP_0068"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Baumannia cicadellinicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "186490.IM45_001";
/// let this_library_node_name2 = "186490.IM45_998";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_baumannia_cicadellinicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_baumannia_cicadellinicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_baumannia_cicadellinicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_baumannia_cicadellinicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["186490"]),
        None,
        Some("."),
        Some("IM45_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrococcus furiosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "186497.PF0001";
/// let this_library_node_name2 = "186497.PF2065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrococcus_furiosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrococcus_furiosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrococcus_furiosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrococcus_furiosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["186497"]),
        None,
        Some("."),
        Some("PF"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alkalilimnicola ehrlichii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "187272.Mlg_0001";
/// let this_library_node_name2 = "187272.Mlg_2884";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alkalilimnicola_ehrlichii_node_name(this_library_node_name1));
/// assert!(is_valid_string_alkalilimnicola_ehrlichii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alkalilimnicola_ehrlichii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alkalilimnicola_ehrlichii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["187272"]),
        None,
        Some("."),
        Some("Mlg_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylocystis sp. SC2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "187303.BN69_0001";
/// let this_library_node_name2 = "187303.BN69_3666";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylocystis_sp_sc2_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylocystis_sp_sc2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylocystis_sp_sc2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylocystis_sp_sc2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["187303"]),
        None,
        Some("."),
        Some("BN69_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dermacoccus sp. Ellin185 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "188626.HMPREF0321_0001";
/// let this_library_node_name2 = "188626.HMPREF0321_2991";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dermacoccus_sp_ellin185_node_name(this_library_node_name1));
/// assert!(is_valid_string_dermacoccus_sp_ellin185_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dermacoccus_sp_ellin185_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dermacoccus_sp_ellin185_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["188626"]),
        None,
        Some("."),
        Some("HMPREF0321_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus graminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "189425.PGRAT_00005";
/// let this_library_node_name2 = "189425.PGRAT_32515";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_graminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_graminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_graminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_graminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["189425"]),
        None,
        Some("."),
        Some("PGRAT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus odorifer nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "189426.PODO_00010";
/// let this_library_node_name2 = "189426.PODO_30595";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_odorifer_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_odorifer_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_odorifer_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_odorifer_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["189426"]),
        None,
        Some("."),
        Some("PODO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. Ec33 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "189753.AXAS01000001_gene3572";
/// let this_library_node_name2 = "189753.AXAS01000160_gene8257";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_ec33_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_ec33_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_ec33_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_ec33_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["189753"]),
        None,
        Some("."),
        Some("AXAS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium nucleatum ATCC25586 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "190304.FN0001";
/// let this_library_node_name2 = "190304.FN2129";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_nucleatum_atcc25586_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_nucleatum_atcc25586_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_nucleatum_atcc25586_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_nucleatum_atcc25586_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["190304"]),
        None,
        Some("."),
        Some("FN"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas axonopodis citri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "190486.XAC0001";
/// let this_library_node_name2 = "190486.XACa0042";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_axonopodis_citri_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_axonopodis_citri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_axonopodis_citri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_axonopodis_citri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["190486"]),
        None,
        Some("."),
        Some("XAC"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caulobacter crescentus CB15 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "190650.CC_0001";
/// let this_library_node_name2 = "190650.CC_3764";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caulobacter_crescentus_cb15_node_name(this_library_node_name1));
/// assert!(is_valid_string_caulobacter_crescentus_cb15_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caulobacter_crescentus_cb15_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caulobacter_crescentus_cb15_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["190650"]),
        None,
        Some("."),
        Some("CC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium atypicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "191610.CATYP_00005";
/// let this_library_node_name2 = "191610.CATYP_10725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_atypicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_atypicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_atypicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_atypicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["191610"]),
        None,
        Some("."),
        Some("CATYP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter jejuni NCTC11168 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "192222.Cj0001";
/// let this_library_node_name2 = "192222.Cj1731c";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_jejuni_nctc11168_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_jejuni_nctc11168_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_jejuni_nctc11168_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_jejuni_nctc11168_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["192222"]),
        None,
        Some("."),
        Some("Cj"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capsaspora owczarzaki nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "192875.XP_004339898.1";
/// let this_library_node_name2 = "192875.XP_004366058.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capsaspora_owczarzaki_node_name(this_library_node_name1));
/// assert!(is_valid_string_capsaspora_owczarzaki_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capsaspora_owczarzaki_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capsaspora_owczarzaki_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["192875"]),
        None,
        Some("."),
        Some("XP_0043"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanosarcina mazei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "192952.MM_0001";
/// let this_library_node_name2 = "192952.MM_3371";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanosarcina_mazei_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanosarcina_mazei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanosarcina_mazei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanosarcina_mazei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["192952"]),
        None,
        Some("."),
        Some("MM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorobium tepidum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "194439.CT0001";
/// let this_library_node_name2 = "194439.CT2288";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorobium_tepidum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorobium_tepidum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorobium_tepidum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorobium_tepidum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["194439"]),
        None,
        Some("."),
        Some("CT"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. ATCC31555 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "194867.ALBQ01000001_gene2917";
/// let this_library_node_name2 = "194867.ALBQ01000062_gene1620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_atcc31555_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_atcc31555_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_atcc31555_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_atcc31555_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["194867"]),
        None,
        Some("."),
        Some("ALBQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium perfringens ATCC13124 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "195103.CPF_0001";
/// let this_library_node_name2 = "195103.CPF_2997";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_perfringens_atcc13124_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_perfringens_atcc13124_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_perfringens_atcc13124_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_perfringens_atcc13124_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["195103"]),
        None,
        Some("."),
        Some("CPF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haematobacter massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "195105.CN97_00005";
/// let this_library_node_name2 = "195105.CN97_20320";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haematobacter_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_haematobacter_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haematobacter_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haematobacter_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["195105"]),
        None,
        Some("."),
        Some("CN97_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. PCC7336 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "195250.CM001776_gene1";
/// let this_library_node_name2 = "195250.CM001776_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_pcc7336_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_pcc7336_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_pcc7336_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_pcc7336_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["195250"]),
        None,
        Some("."),
        Some("CM001776_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. PCC6312 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "195253.Syn6312_0001";
/// let this_library_node_name2 = "195253.Syn6312_3795";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_pcc6312_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_pcc6312_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_pcc6312_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_pcc6312_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["195253"]),
        None,
        Some("."),
        Some("Syn6312_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermococcus nautili nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "195522.BD01_0001";
/// let this_library_node_name2 = "195522.BD01_2288";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermococcus_nautili_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermococcus_nautili_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermococcus_nautili_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermococcus_nautili_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["195522"]),
        None,
        Some("."),
        Some("BD01_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardioides sp. JS614 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "196162.Noca_0001";
/// let this_library_node_name2 = "196162.Noca_4971";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardioides_sp_js614_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardioides_sp_js614_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardioides_sp_js614_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardioides_sp_js614_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["196162"]),
        None,
        Some("."),
        Some("Noca_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium efficiens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "196164.23491836";
/// let this_library_node_name2 = "196164.23494853";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_efficiens_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_efficiens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_efficiens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_efficiens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["196164"]),
        None,
        Some("."),
        Some("2349"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sordidicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "196367.JNFG01000001_gene1906";
/// let this_library_node_name2 = "196367.JNFG01000216_gene692";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sordidicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sordidicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sordidicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sordidicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["196367"]),
        None,
        Some("."),
        Some("JNFG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. Ai1a2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "196490.AUEZ01000001_gene7284";
/// let this_library_node_name2 = "196490.AUEZ01000248_gene5828";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_ai1a2_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_ai1a2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_ai1a2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_ai1a2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["196490"]),
        None,
        Some("."),
        Some("AUEZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium glutamicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "196627.cg0001";
/// let this_library_node_name2 = "196627.cg4007";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_glutamicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_glutamicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_glutamicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_glutamicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["196627"]),
        None,
        Some("."),
        Some("cg"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermosynechococcus elongatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "197221.163937831";
/// let this_library_node_name2 = "197221.22296204";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermosynechococcus_elongatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermosynechococcus_elongatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermosynechococcus_elongatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermosynechococcus_elongatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["197221"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus anthracis Ames nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "198094.BA_0001";
/// let this_library_node_name2 = "198094.BA_5873";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_anthracis_ames_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_anthracis_ames_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_anthracis_ames_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_anthracis_ames_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["198094"]),
        None,
        Some("."),
        Some("BA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shigella flexneri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "198214.CP0001";
/// let this_library_node_name2 = "198214.SF4434";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shigella_flexneri_node_name(this_library_node_name1));
/// assert!(is_valid_string_shigella_flexneri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shigella_flexneri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shigella_flexneri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["198214"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anoxybacillus gonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "198467.NP92_00005";
/// let this_library_node_name2 = "198467.NP92_14635";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anoxybacillus_gonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anoxybacillus_gonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anoxybacillus_gonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anoxybacillus_gonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["198467"]),
        None,
        Some("."),
        Some("NP92_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dickeya dadantii 3937 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "198628.Dda3937_00001";
/// let this_library_node_name2 = "198628.Dda3937_04717";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dickeya_dadantii_3937_node_name(this_library_node_name1));
/// assert!(is_valid_string_dickeya_dadantii_3937_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dickeya_dadantii_3937_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dickeya_dadantii_3937_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["198628"]),
        None,
        Some("."),
        Some("Dda3937_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Buchnera aphidicola Sg nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "198804.BUsg_001";
/// let this_library_node_name2 = "198804.BUsg_583";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_buchnera_aphidicola_sg_node_name(this_library_node_name1));
/// assert!(is_valid_string_buchnera_aphidicola_sg_node_name(this_library_node_name2));
/// assert!(!is_valid_string_buchnera_aphidicola_sg_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_buchnera_aphidicola_sg_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["198804"]),
        None,
        Some("."),
        Some("BUsg_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coccidioides posadasii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "199306.XP_003064998.1";
/// let this_library_node_name2 = "199306.XP_003072226.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coccidioides_posadasii_node_name(this_library_node_name1));
/// assert!(is_valid_string_coccidioides_posadasii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coccidioides_posadasii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coccidioides_posadasii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["199306"]),
        None,
        Some("."),
        Some("XP_0030"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia coli CFT073 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "199310.c0002";
/// let this_library_node_name2 = "199310.c5625";
/// let not_this_library_node_name1 = "CORD:9216572432e045a1492311f16f7b74e8f6dc575e";
/// let not_this_library_node_name2 = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_coli_cft073_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_coli_cft073_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_coli_cft073_node_name(not_this_library_node_name1));
/// assert!(!is_valid_string_escherichia_coli_cft073_node_name(not_this_library_node_name2));
/// ```
pub fn is_valid_string_escherichia_coli_cft073_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["199310"]),
        Some(12),
        Some("."),
        Some("c"),
        Some(5),
        Some(4),
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Punctularia strigosozonata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "202698.XP_007378011.1";
/// let this_library_node_name2 = "202698.XP_007389550.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_punctularia_strigosozonata_node_name(this_library_node_name1));
/// assert!(is_valid_string_punctularia_strigosozonata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_punctularia_strigosozonata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_punctularia_strigosozonata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["202698"]),
        None,
        Some("."),
        Some("XP_0073"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeria ivanovii londoniensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "202752.JL53_00005";
/// let this_library_node_name2 = "202752.JL53_15065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeria_ivanovii_londoniensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeria_ivanovii_londoniensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeria_ivanovii_londoniensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeria_ivanovii_londoniensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["202752"]),
        None,
        Some("."),
        Some("JL53_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter gerneri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "202952.BBLI01000001_gene1";
/// let this_library_node_name2 = "202952.BBLI01000185_gene4097";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_gerneri_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_gerneri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_gerneri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_gerneri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["202952"]),
        None,
        Some("."),
        Some("BBLI01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter tandoii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "202954.BBNK01000001_gene475";
/// let this_library_node_name2 = "202954.BBNK01000095_gene2385";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_tandoii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_tandoii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_tandoii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_tandoii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["202954"]),
        None,
        Some("."),
        Some("BBNK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter tjernbergiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "202955.BBND01000001_gene1180";
/// let this_library_node_name2 = "202955.BBND01000055_gene1764";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_tjernbergiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_tjernbergiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_tjernbergiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_tjernbergiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["202955"]),
        None,
        Some("."),
        Some("BBND010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter towneri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "202956.BBNL01000001_gene1502";
/// let this_library_node_name2 = "202956.BBNL01000107_gene1833";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_towneri_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_towneri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_towneri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_towneri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["202956"]),
        None,
        Some("."),
        Some("BBNL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminiclostridium thermocellum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "203119.Cthe_0001";
/// let this_library_node_name2 = "203119.Cthe_3454";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminiclostridium_thermocellum_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminiclostridium_thermocellum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminiclostridium_thermocellum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminiclostridium_thermocellum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["203119"]),
        None,
        Some("."),
        Some("Cthe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leuconostoc mesenteroides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "203120.LEUM_0001";
/// let this_library_node_name2 = "203120.LEUM_A35";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leuconostoc_mesenteroides_node_name(this_library_node_name1));
/// assert!(is_valid_string_leuconostoc_mesenteroides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leuconostoc_mesenteroides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leuconostoc_mesenteroides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["203120"]),
        None,
        Some("."),
        Some("LEUM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharophagus degradans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "203122.Sde_0001";
/// let this_library_node_name2 = "203122.Sde_4017";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharophagus_degradans_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharophagus_degradans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharophagus_degradans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharophagus_degradans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["203122"]),
        None,
        Some("."),
        Some("Sde_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oenococcus oeni nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "203123.OEOE_0001";
/// let this_library_node_name2 = "203123.OEOE_1864";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oenococcus_oeni_node_name(this_library_node_name1));
/// assert!(is_valid_string_oenococcus_oeni_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oenococcus_oeni_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oenococcus_oeni_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["203123"]),
        None,
        Some("."),
        Some("OEOE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trichodesmium erythraeum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "203124.Tery_0001";
/// let this_library_node_name2 = "203124.Tery_5078";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trichodesmium_erythraeum_node_name(this_library_node_name1));
/// assert!(is_valid_string_trichodesmium_erythraeum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trichodesmium_erythraeum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trichodesmium_erythraeum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["203124"]),
        None,
        Some("."),
        Some("Tery_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tropheryma whipplei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "203267.TWT_001";
/// let this_library_node_name2 = "203267.TWT_808";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tropheryma_whipplei_node_name(this_library_node_name1));
/// assert!(is_valid_string_tropheryma_whipplei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tropheryma_whipplei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tropheryma_whipplei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["203267"]),
        None,
        Some("."),
        Some("TWT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tannerella forsythia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "203275.BFO_0001";
/// let this_library_node_name2 = "203275.BFO_3363";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tannerella_forsythia_node_name(this_library_node_name1));
/// assert!(is_valid_string_tannerella_forsythia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tannerella_forsythia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tannerella_forsythia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["203275"]),
        None,
        Some("."),
        Some("BFO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blochmannia floridanus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "203907.Bfl001";
/// let this_library_node_name2 = "203907.Bfl630";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blochmannia_floridanus_node_name(this_library_node_name1));
/// assert!(is_valid_string_blochmannia_floridanus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blochmannia_floridanus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blochmannia_floridanus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["203907"]),
        None,
        Some("."),
        Some("Bfl"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Melampsora laricipopulina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "203908.EGF96883";
/// let this_library_node_name2 = "203908.EGG13255";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_melampsora_laricipopulina_node_name(this_library_node_name1));
/// assert!(is_valid_string_melampsora_laricipopulina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_melampsora_laricipopulina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_melampsora_laricipopulina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["203908"]),
        None,
        Some("."),
        Some("EG"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurihydrogenibium azorense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "204536.SULAZ_0007";
/// let this_library_node_name2 = "204536.SULAZ_1772";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurihydrogenibium_azorense_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurihydrogenibium_azorense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurihydrogenibium_azorense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurihydrogenibium_azorense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["204536"]),
        None,
        Some("."),
        Some("SULAZ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Koribacter versatilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "204669.Acid345_0001";
/// let this_library_node_name2 = "204669.Acid345_4783";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_koribacter_versatilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_koribacter_versatilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_koribacter_versatilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_koribacter_versatilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["204669"]),
        None,
        Some("."),
        Some("Acid345_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Herminiimonas arsenicoxydans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "204773.HEAR0001";
/// let this_library_node_name2 = "204773.HEAR3472";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_herminiimonas_arsenicoxydans_node_name(this_library_node_name1));
/// assert!(is_valid_string_herminiimonas_arsenicoxydans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_herminiimonas_arsenicoxydans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_herminiimonas_arsenicoxydans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["204773"]),
        None,
        Some("."),
        Some("HEAR"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haemophilus somnus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "205914.HS_0001";
/// let this_library_node_name2 = "205914.HS_p06";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haemophilus_somnus_node_name(this_library_node_name1));
/// assert!(is_valid_string_haemophilus_somnus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haemophilus_somnus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haemophilus_somnus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["205914"]),
        None,
        Some("."),
        Some("HS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas syringae B728a nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "205918.Psyr_0001";
/// let this_library_node_name2 = "205918.Psyr_5137";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_syringae_b728a_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_syringae_b728a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_syringae_b728a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_syringae_b728a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["205918"]),
        None,
        Some("."),
        Some("Psyr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ehrlichia chaffeensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "205920.ECH_0001";
/// let this_library_node_name2 = "205920.ECH_1156";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ehrlichia_chaffeensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ehrlichia_chaffeensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ehrlichia_chaffeensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ehrlichia_chaffeensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["205920"]),
        None,
        Some("."),
        Some("ECH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas fluorescens Pf01 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "205922.Pfl01_0001";
/// let this_library_node_name2 = "205922.Pfl01_5747";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_fluorescens_pf01_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_fluorescens_pf01_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_fluorescens_pf01_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_fluorescens_pf01_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["205922"]),
        None,
        Some("."),
        Some("Pfl01_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio alaskensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "207559.Dde_0001";
/// let this_library_node_name2 = "207559.Dde_4057";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_alaskensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_alaskensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_alaskensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_alaskensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["207559"]),
        None,
        Some("."),
        Some("Dde_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neptuniibacter caesariensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "207954.MED92_00005";
/// let this_library_node_name2 = "207954.MED92_18538";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neptuniibacter_caesariensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_neptuniibacter_caesariensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neptuniibacter_caesariensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neptuniibacter_caesariensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["207954"]),
        None,
        Some("."),
        Some("MED92_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolatopsis japonica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "208439.AJAP_00005";
/// let this_library_node_name2 = "208439.AJAP_42995";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolatopsis_japonica_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolatopsis_japonica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolatopsis_japonica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolatopsis_japonica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["208439"]),
        None,
        Some("."),
        Some("AJAP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolatopsis vancoresmycina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "208444.JNYY01000001_gene4704";
/// let this_library_node_name2 = "208444.JNYY01000081_gene4504";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolatopsis_vancoresmycina_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolatopsis_vancoresmycina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolatopsis_vancoresmycina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolatopsis_vancoresmycina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["208444"]),
        None,
        Some("."),
        Some("JNYY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carnobacterium sp. 174 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "208596.CAR_50p010";
/// let this_library_node_name2 = "208596.CAR_c25210";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carnobacterium_sp_174_node_name(this_library_node_name1));
/// assert!(is_valid_string_carnobacterium_sp_174_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carnobacterium_sp_174_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carnobacterium_sp_174_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["208596"]),
        None,
        Some("."),
        Some("CAR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fomitiporia mediterranea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "208960.XP_007261132.1";
/// let this_library_node_name2 = "208960.XP_007272469.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fomitiporia_mediterranea_node_name(this_library_node_name1));
/// assert!(is_valid_string_fomitiporia_mediterranea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fomitiporia_mediterranea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fomitiporia_mediterranea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["208960"]),
        None,
        Some("."),
        Some("XP_0072"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chaetomium thermophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "209285.XP_006690561.1";
/// let this_library_node_name2 = "209285.XP_006697725.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chaetomium_thermophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chaetomium_thermophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chaetomium_thermophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chaetomium_thermophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["209285"]),
        None,
        Some("."),
        Some("XP_00669"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mutans UA159 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "210007.SMU_01";
/// let this_library_node_name2 = "210007.SMU_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mutans_ua159_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mutans_ua159_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mutans_ua159_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mutans_ua159_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["210007"]),
        None,
        Some("."),
        Some("SMU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus agalactiae NEM316 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "211110.gbs0001";
/// let this_library_node_name2 = "211110.gbsp002";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_agalactiae_nem316_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_agalactiae_nem316_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_agalactiae_nem316_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_agalactiae_nem316_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["211110"]),
        None,
        Some("."),
        Some("gbs"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Allokutzneria albata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "211114.JOEF01000001_gene6913";
/// let this_library_node_name2 = "211114.JOEF01000155_gene4676";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_allokutzneria_albata_node_name(this_library_node_name1));
/// assert!(is_valid_string_allokutzneria_albata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_allokutzneria_albata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_allokutzneria_albata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["211114"]),
        None,
        Some("."),
        Some("JOEF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorogloeopsis fritschii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "211165.AJLN01000001_gene6358";
/// let this_library_node_name2 = "211165.AJLN01000161_gene5602";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorogloeopsis_fritschii_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorogloeopsis_fritschii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorogloeopsis_fritschii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorogloeopsis_fritschii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["211165"]),
        None,
        Some("."),
        Some("AJLN01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella oneidensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "211586.SO_0001";
/// let this_library_node_name2 = "211586.SO_4844";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_oneidensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_oneidensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_oneidensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_oneidensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["211586"]),
        None,
        Some("."),
        Some("SO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaplasma phagocytophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "212042.APH_0001";
/// let this_library_node_name2 = "212042.APH_1414";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaplasma_phagocytophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaplasma_phagocytophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaplasma_phagocytophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaplasma_phagocytophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["212042"]),
        None,
        Some("."),
        Some("APH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yersinia pestis CO92 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "214092.5832424";
/// let this_library_node_name2 = "214092.YPO4130";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yersinia_pestis_co92_node_name(this_library_node_name1));
/// assert!(is_valid_string_yersinia_pestis_co92_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yersinia_pestis_co92_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yersinia_pestis_co92_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["214092"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Larimichthys crocea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "215358.XP_010727418.1";
/// let this_library_node_name2 = "215358.XP_010755649.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_larimichthys_crocea_node_name(this_library_node_name1));
/// assert!(is_valid_string_larimichthys_crocea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_larimichthys_crocea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_larimichthys_crocea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["215358"]),
        None,
        Some("."),
        Some("XP_0107"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enhygromyxa salina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "215803.DB30_0001";
/// let this_library_node_name2 = "215803.DB30_8931";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enhygromyxa_salina_node_name(this_library_node_name1));
/// assert!(is_valid_string_enhygromyxa_salina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enhygromyxa_salina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enhygromyxa_salina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["215803"]),
        None,
        Some("."),
        Some("DB30_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas rhizosphaerae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "216142.LT40_00025";
/// let this_library_node_name2 = "216142.LT40_21190";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_rhizosphaerae_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_rhizosphaerae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_rhizosphaerae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_rhizosphaerae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["216142"]),
        None,
        Some("."),
        Some("LT40_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Croceibacter atlanticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "216432.CA2559_00005";
/// let this_library_node_name2 = "216432.CA2559_13653";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_croceibacter_atlanticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_croceibacter_atlanticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_croceibacter_atlanticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_croceibacter_atlanticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["216432"]),
        None,
        Some("."),
        Some("CA2559_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia cenocepacia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "216591.BCAL0001";
/// let this_library_node_name2 = "216591.pBCA095";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_cenocepacia_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_cenocepacia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_cenocepacia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_cenocepacia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["216591"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium marinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "216594.MMAR_0001";
/// let this_library_node_name2 = "216594.MMAR_p33";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_marinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_marinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_marinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_marinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["216594"]),
        None,
        Some("."),
        Some("MMAR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas fluorescens SBW25 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "216595.PFLU_0001";
/// let this_library_node_name2 = "216595.PFLU_6136";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_fluorescens_sbw25_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_fluorescens_sbw25_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_fluorescens_sbw25_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_fluorescens_sbw25_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["216595"]),
        None,
        Some("."),
        Some("PFLU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium leguminosarum 3841 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "216596.RL0001";
/// let this_library_node_name2 = "216596.pRL80142";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_leguminosarum_3841_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_leguminosarum_3841_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_leguminosarum_3841_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_leguminosarum_3841_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["216596"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium longum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "216816.GS08_00005";
/// let this_library_node_name2 = "216816.GS08_10590";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_longum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_longum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_longum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_longum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["216816"]),
        None,
        Some("."),
        Some("GS08_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium psychraerophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "218140.BPSY_0001";
/// let this_library_node_name2 = "218140.BPSY_4000";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_psychraerophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_psychraerophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_psychraerophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_psychraerophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["218140"]),
        None,
        Some("."),
        Some("BPSY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus vietnamensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "218284.CCDN010000001_gene1";
/// let this_library_node_name2 = "218284.CCDN010000012_gene4453";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_vietnamensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_vietnamensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_vietnamensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_vietnamensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["218284"]),
        None,
        Some("."),
        Some("CCDN0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pectobacterium atrosepticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "218491.ECA0001";
/// let this_library_node_name2 = "218491.ECA4521";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pectobacterium_atrosepticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_pectobacterium_atrosepticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pectobacterium_atrosepticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pectobacterium_atrosepticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["218491"]),
        None,
        Some("."),
        Some("ECA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salmonella bongori NCTC12419 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "218493.SBG_0001";
/// let this_library_node_name2 = "218493.SBG_4005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salmonella_bongori_nctc12419_node_name(this_library_node_name1));
/// assert!(is_valid_string_salmonella_bongori_nctc12419_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salmonella_bongori_nctc12419_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salmonella_bongori_nctc12419_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["218493"]),
        None,
        Some("."),
        Some("SBG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus uberis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "218495.SUB0001";
/// let this_library_node_name2 = "218495.SUB1869";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_uberis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_uberis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_uberis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_uberis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["218495"]),
        None,
        Some("."),
        Some("SUB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydophila abortus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "218497.CAB001";
/// let this_library_node_name2 = "218497.CAB981";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydophila_abortus_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydophila_abortus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydophila_abortus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydophila_abortus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["218497"]),
        None,
        Some("."),
        Some("CAB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquilegia coerulea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "218851.Aquca_001_00001.1";
/// let this_library_node_name2 = "218851.Aquca_966_00001.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquilegia_coerulea_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquilegia_coerulea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquilegia_coerulea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquilegia_coerulea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["218851"]),
        None,
        Some("."),
        Some("Aquca_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Micromonospora sp. ATCC39149 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "219305.MCAG_00001";
/// let this_library_node_name2 = "219305.MCAG_05633";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_micromonospora_sp_atcc39149_node_name(this_library_node_name1));
/// assert!(is_valid_string_micromonospora_sp_atcc39149_node_name(this_library_node_name2));
/// assert!(!is_valid_string_micromonospora_sp_atcc39149_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_micromonospora_sp_atcc39149_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["219305"]),
        None,
        Some("."),
        Some("MCAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salmonella enterica CT18 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "220341.16501284";
/// let this_library_node_name2 = "220341.16506113";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salmonella_enterica_ct18_node_name(this_library_node_name1));
/// assert!(is_valid_string_salmonella_enterica_ct18_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salmonella_enterica_ct18_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salmonella_enterica_ct18_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["220341"]),
        None,
        Some("."),
        Some("1650"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas protegens Pf5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "220664.PFL_0001";
/// let this_library_node_name2 = "220664.PFL_6284";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_protegens_pf5_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_protegens_pf5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_protegens_pf5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_protegens_pf5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["220664"]),
        None,
        Some("."),
        Some("PFL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus plantarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "220668.342242703";
/// let this_library_node_name2 = "220668.lp_3688a";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_plantarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_plantarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_plantarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_plantarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["220668"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema putidum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "221027.JO40_00010";
/// let this_library_node_name2 = "221027.JO40_13460";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_putidum_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_putidum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_putidum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_putidum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["221027"]),
        None,
        Some("."),
        Some("JO40_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moniliophthora roreri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "221103.XP_007842186.1";
/// let this_library_node_name2 = "221103.XP_007860095.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moniliophthora_roreri_node_name(this_library_node_name1));
/// assert!(is_valid_string_moniliophthora_roreri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moniliophthora_roreri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moniliophthora_roreri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["221103"]),
        None,
        Some("."),
        Some("XP_0078"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanobacillus iheyensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "221109.22775679";
/// let this_library_node_name2 = "221109.22779186";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanobacillus_iheyensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanobacillus_iheyensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanobacillus_iheyensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanobacillus_iheyensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["221109"]),
        None,
        Some("."),
        Some("2277"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mastigocladopsis repens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "221288.JH992899_gene1";
/// let this_library_node_name2 = "221288.JH992901_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mastigocladopsis_repens_node_name(this_library_node_name1));
/// assert!(is_valid_string_mastigocladopsis_repens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mastigocladopsis_repens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mastigocladopsis_repens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["221288"]),
        None,
        Some("."),
        Some("JH992"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. RS9916 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "221359.RS9916_25609";
/// let this_library_node_name2 = "221359.RS9916_40481";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_rs9916_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_rs9916_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_rs9916_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_rs9916_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["221359"]),
        None,
        Some("."),
        Some("RS9916_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. RS9917 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "221360.RS9917_00005";
/// let this_library_node_name2 = "221360.RS9917_13948";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_rs9917_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_rs9917_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_rs9917_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_rs9917_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["221360"]),
        None,
        Some("."),
        Some("RS9917_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mannheimia succiniciproducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "221988.MS0001";
/// let this_library_node_name2 = "221988.MS2384";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mannheimia_succiniciproducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_mannheimia_succiniciproducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mannheimia_succiniciproducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mannheimia_succiniciproducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["221988"]),
        None,
        Some("."),
        Some("MS"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frankia sp. BMG512 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "222534.KB893670_gene3609";
/// let this_library_node_name2 = "222534.KB893804_gene3991";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frankia_sp_bmg512_node_name(this_library_node_name1));
/// assert!(is_valid_string_frankia_sp_bmg512_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frankia_sp_bmg512_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frankia_sp_bmg512_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["222534"]),
        None,
        Some("."),
        Some("KB893"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neorickettsia sennetsu nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "222891.NSE_0001";
/// let this_library_node_name2 = "222891.NSE_0971";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neorickettsia_sennetsu_node_name(this_library_node_name1));
/// assert!(is_valid_string_neorickettsia_sennetsu_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neorickettsia_sennetsu_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neorickettsia_sennetsu_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["222891"]),
        None,
        Some("."),
        Some("NSE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natrinema altunense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "222984.JNCS01000001_gene1644";
/// let this_library_node_name2 = "222984.JNCS01000020_gene3238";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natrinema_altunense_node_name(this_library_node_name1));
/// assert!(is_valid_string_natrinema_altunense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natrinema_altunense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natrinema_altunense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["222984"]),
        None,
        Some("."),
        Some("JNCS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kocuria marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "223184.AS25_00005";
/// let this_library_node_name2 = "223184.AS25_13675";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kocuria_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_kocuria_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kocuria_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kocuria_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["223184"]),
        None,
        Some("."),
        Some("AS25_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Togninia minima nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "223192.XP_007910790.1";
/// let this_library_node_name2 = "223192.XP_007919623.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_togninia_minima_node_name(this_library_node_name1));
/// assert!(is_valid_string_togninia_minima_node_name(this_library_node_name2));
/// assert!(!is_valid_string_togninia_minima_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_togninia_minima_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["223192"]),
        None,
        Some("."),
        Some("XP_00791"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas syringae tomato nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "223283.PSPTO_0001";
/// let this_library_node_name2 = "223283.PSPTO_A0072";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_syringae_tomato_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_syringae_tomato_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_syringae_tomato_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_syringae_tomato_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["223283"]),
        None,
        Some("."),
        Some("PSPTO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio parahaemolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "223926.28804983";
/// let this_library_node_name2 = "223926.28810154";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_parahaemolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_parahaemolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_parahaemolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_parahaemolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["223926"]),
        None,
        Some("."),
        Some("288"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus subtilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "224308.BSU00010";
/// let this_library_node_name2 = "224308.BSU41060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_subtilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_subtilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_subtilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_subtilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["224308"]),
        None,
        Some("."),
        Some("BSU"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquifex aeolicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "224324.2984354";
/// let this_library_node_name2 = "224324.aq_aa40";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquifex_aeolicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquifex_aeolicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquifex_aeolicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquifex_aeolicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["224324"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Archaeoglobus fulgidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "224325.AF_0001";
/// let this_library_node_name2 = "224325.AF_2436";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_archaeoglobus_fulgidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_archaeoglobus_fulgidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_archaeoglobus_fulgidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_archaeoglobus_fulgidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["224325"]),
        None,
        Some("."),
        Some("AF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanobrevibacter sp. AbM4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "224719.Abm4_0001";
/// let this_library_node_name2 = "224719.Abm4_1739";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanobrevibacter_sp_abm4_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanobrevibacter_sp_abm4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanobrevibacter_sp_abm4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanobrevibacter_sp_abm4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["224719"]),
        None,
        Some("."),
        Some("Abm4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium diazoefficiens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "224911.27348248";
/// let this_library_node_name2 = "224911.27356603";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_diazoefficiens_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_diazoefficiens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_diazoefficiens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_diazoefficiens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["224911"]),
        None,
        Some("."),
        Some("273"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brucella melitensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "224914.BMEI0001";
/// let this_library_node_name2 = "224914.BMEII1138";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brucella_melitensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_brucella_melitensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brucella_melitensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brucella_melitensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["224914"]),
        None,
        Some("."),
        Some("BMEI"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Buchnera aphidicola Bp nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "224915.28076688";
/// let this_library_node_name2 = "224915.bbp_550";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_buchnera_aphidicola_bp_node_name(this_library_node_name1));
/// assert!(is_valid_string_buchnera_aphidicola_bp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_buchnera_aphidicola_bp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_buchnera_aphidicola_bp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["224915"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrus x bretschneideri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "225117.XP_009333588.1";
/// let this_library_node_name2 = "225117.XP_009379761.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrus_x_bretschneideri_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrus_x_bretschneideri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrus_x_bretschneideri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrus_x_bretschneideri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["225117"]),
        None,
        Some("."),
        Some("XP_0093"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myotis davidii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "225400.XP_006752630.1";
/// let this_library_node_name2 = "225400.XP_006779742.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myotis_davidii_node_name(this_library_node_name1));
/// assert!(is_valid_string_myotis_davidii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myotis_davidii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myotis_davidii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["225400"]),
        None,
        Some("."),
        Some("XP_0067"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella piezotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "225849.swp_0001";
/// let this_library_node_name2 = "225849.swp_5167";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_piezotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_piezotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_piezotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_piezotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["225849"]),
        None,
        Some("."),
        Some("swp_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter adhaerens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "225937.HP15_1";
/// let this_library_node_name2 = "225937.HP15_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_adhaerens_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_adhaerens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_adhaerens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_adhaerens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["225937"]),
        None,
        Some("."),
        Some("HP15_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus faecalis V583 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "226185.EF_0001";
/// let this_library_node_name2 = "226185.EF_3333";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_faecalis_v583_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_faecalis_v583_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_faecalis_v583_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_faecalis_v583_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["226185"]),
        None,
        Some("."),
        Some("EF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides thetaiotaomicron nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "226186.BT_0001";
/// let this_library_node_name2 = "226186.BT_p548238";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_thetaiotaomicron_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_thetaiotaomicron_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_thetaiotaomicron_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_thetaiotaomicron_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["226186"]),
        None,
        Some("."),
        Some("BT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Grosmannia clavigera nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "226899.F0X6H9";
/// let this_library_node_name2 = "226899.F0XV90";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_grosmannia_clavigera_node_name(this_library_node_name1));
/// assert!(is_valid_string_grosmannia_clavigera_node_name(this_library_node_name2));
/// assert!(!is_valid_string_grosmannia_clavigera_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_grosmannia_clavigera_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["226899"]),
        None,
        Some("."),
        Some("F0X"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bigelowiella natans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "227086.JGI_V11_125293";
/// let this_library_node_name2 = "227086.JGI_V11_93001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bigelowiella_natans_node_name(this_library_node_name1));
/// assert!(is_valid_string_bigelowiella_natans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bigelowiella_natans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bigelowiella_natans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["227086"]),
        None,
        Some("."),
        Some("JGI_V11_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coxiella burnetii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "227377.CBUA0001";
/// let this_library_node_name2 = "227377.CBU_2097";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coxiella_burnetii_node_name(this_library_node_name1));
/// assert!(is_valid_string_coxiella_burnetii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coxiella_burnetii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coxiella_burnetii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["227377"]),
        None,
        Some("."),
        Some("CBU"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces avermitilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "227882.SAP1_1";
/// let this_library_node_name2 = "227882.SAV_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_avermitilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_avermitilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_avermitilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_avermitilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["227882"]),
        None,
        Some("."),
        Some("SA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydophila caviae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "227941.CCAA00001";
/// let this_library_node_name2 = "227941.CCA_01012";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydophila_caviae_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydophila_caviae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydophila_caviae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydophila_caviae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["227941"]),
        None,
        Some("."),
        Some("CCA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobacillus pleuropneumoniae 1 4074 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "228399.appser1_10";
/// let this_library_node_name2 = "228399.appser1_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobacillus_pleuropneumoniae_1_4074_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobacillus_pleuropneumoniae_1_4074_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobacillus_pleuropneumoniae_1_4074_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobacillus_pleuropneumoniae_1_4074_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["228399"]),
        None,
        Some("."),
        Some("appser1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas neptunium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "228405.HNE_0001";
/// let this_library_node_name2 = "228405.HNE_3568";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_neptunium_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_neptunium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_neptunium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_neptunium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["228405"]),
        None,
        Some("."),
        Some("HNE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosomonas europaea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "228410.NE0001";
/// let this_library_node_name2 = "228410.NE2575";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosomonas_europaea_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosomonas_europaea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosomonas_europaea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosomonas_europaea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["228410"]),
        None,
        Some("."),
        Some("NE"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Beijerinckia mobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "231434.JQJH01000001_gene1666";
/// let this_library_node_name2 = "231434.JQJH01000055_gene2072";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_beijerinckia_mobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_beijerinckia_mobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_beijerinckia_mobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_beijerinckia_mobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["231434"]),
        None,
        Some("."),
        Some("JQJH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas alkaliantarctica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "232346.JHQL01000001_gene2035";
/// let this_library_node_name2 = "232346.JHQL01000020_gene2921";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_alkaliantarctica_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_alkaliantarctica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_alkaliantarctica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_alkaliantarctica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["232346"]),
        None,
        Some("."),
        Some("JHQL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. CB0101 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "232348.ADXL01000001_gene326";
/// let this_library_node_name2 = "232348.ADXL01000093_gene423";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_cb0101_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_cb0101_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_cb0101_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_cb0101_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["232348"]),
        None,
        Some("."),
        Some("ADXL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidovorax sp. JS42 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "232721.Ajs_0001";
/// let this_library_node_name2 = "232721.Ajs_4320";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidovorax_sp_js42_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidovorax_sp_js42_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidovorax_sp_js42_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidovorax_sp_js42_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["232721"]),
        None,
        Some("."),
        Some("Ajs_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haemophilus ducreyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "233412.HD_0001";
/// let this_library_node_name2 = "233412.HD_2037";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haemophilus_ducreyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_haemophilus_ducreyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haemophilus_ducreyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haemophilus_ducreyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["233412"]),
        None,
        Some("."),
        Some("HD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solibacter usitatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "234267.Acid_0001";
/// let this_library_node_name2 = "234267.Acid_7951";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solibacter_usitatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_solibacter_usitatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solibacter_usitatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solibacter_usitatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["234267"]),
        None,
        Some("."),
        Some("Acid_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus erythropolis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "234621.RER_00010";
/// let this_library_node_name2 = "234621.RER_pREC1-01020";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_erythropolis_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_erythropolis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_erythropolis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_erythropolis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["234621"]),
        None,
        Some("."),
        Some("RER_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaplasma marginale Maries nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "234826.AM001";
/// let this_library_node_name2 = "234826.AM999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaplasma_marginale_maries_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaplasma_marginale_maries_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaplasma_marginale_maries_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaplasma_marginale_maries_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["234826"]),
        None,
        Some("."),
        Some("AM"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas sp. SM9913 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "234831.PSM_A0001";
/// let this_library_node_name2 = "234831.PSM_B0641";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_sp_sm9913_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_sp_sm9913_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_sp_sm9913_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_sp_sm9913_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["234831"]),
        None,
        Some("."),
        Some("PSM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter hepaticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "235279.HH_0001";
/// let this_library_node_name2 = "235279.HH_1875";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_hepaticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_hepaticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_hepaticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_hepaticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["235279"]),
        None,
        Some("."),
        Some("HH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacillus kaustophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "235909.GK0001";
/// let this_library_node_name2 = "235909.GKP42";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacillus_kaustophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacillus_kaustophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacillus_kaustophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacillus_kaustophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["235909"]),
        None,
        Some("."),
        Some("GK"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptacidiphilus jiangxiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "235985.BBPN01000001_gene1000";
/// let this_library_node_name2 = "235985.BBPN01000096_gene2755";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptacidiphilus_jiangxiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptacidiphilus_jiangxiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptacidiphilus_jiangxiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptacidiphilus_jiangxiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["235985"]),
        None,
        Some("."),
        Some("BBPN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alcanivorax sp. DG881 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "236097.ADG881_1";
/// let this_library_node_name2 = "236097.ADG881_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alcanivorax_sp_dg881_node_name(this_library_node_name1));
/// assert!(is_valid_string_alcanivorax_sp_dg881_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alcanivorax_sp_dg881_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alcanivorax_sp_dg881_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["236097"]),
        None,
        Some("."),
        Some("ADG881_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium formosense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "236814.IX39_00005";
/// let this_library_node_name2 = "236814.IX39_20725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_formosense_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_formosense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_formosense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_formosense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["236814"]),
        None,
        Some("."),
        Some("IX39_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Scalindua brodae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "237368.SCABRO_00001";
/// let this_library_node_name2 = "237368.SCABRO_04055";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_scalindua_brodae_node_name(this_library_node_name1));
/// assert!(is_valid_string_scalindua_brodae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_scalindua_brodae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_scalindua_brodae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["237368"]),
        None,
        Some("."),
        Some("SCABRO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas alkylphenolia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "237609.PSAKL28_00010";
/// let this_library_node_name2 = "237609.PSAKL28_52750";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_alkylphenolia_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_alkylphenolia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_alkylphenolia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_alkylphenolia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["237609"]),
        None,
        Some("."),
        Some("PSAKL28_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erythrobacter sp. NAP1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "237727.NAP1_00005";
/// let this_library_node_name2 = "237727.NAP1_15943";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erythrobacter_sp_nap1_node_name(this_library_node_name1));
/// assert!(is_valid_string_erythrobacter_sp_nap1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erythrobacter_sp_nap1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erythrobacter_sp_nap1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["237727"]),
        None,
        Some("."),
        Some("NAP1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidobacterium capsulatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "240015.ACP_0001";
/// let this_library_node_name2 = "240015.ACP_3547";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidobacterium_capsulatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidobacterium_capsulatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidobacterium_capsulatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidobacterium_capsulatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["240015"]),
        None,
        Some("."),
        Some("ACP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Verrucomicrobium spinosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "240016.ABIZ01000001_gene1";
/// let this_library_node_name2 = "240016.ABIZ01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_verrucomicrobium_spinosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_verrucomicrobium_spinosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_verrucomicrobium_spinosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_verrucomicrobium_spinosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["240016"]),
        None,
        Some("."),
        Some("ABIZ01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anabaena variabilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "240292.Ava_0001";
/// let this_library_node_name2 = "240292.Ava_D0049";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anabaena_variabilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anabaena_variabilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anabaena_variabilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anabaena_variabilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["240292"]),
        None,
        Some("."),
        Some("Ava_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halobacillus dabanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "240302.BN982_00001";
/// let this_library_node_name2 = "240302.BN982_04239";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halobacillus_dabanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_halobacillus_dabanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halobacillus_dabanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halobacillus_dabanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["240302"]),
        None,
        Some("."),
        Some("BN982_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ostreococcus lucimarinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "242159.ABO93650";
/// let this_library_node_name2 = "242159.ABP01319";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ostreococcus_lucimarinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ostreococcus_lucimarinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ostreococcus_lucimarinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ostreococcus_lucimarinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["242159"]),
        None,
        Some("."),
        Some("AB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas gingivalis W83 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "242619.PG_0001";
/// let this_library_node_name2 = "242619.PG_2227";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_gingivalis_w83_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_gingivalis_w83_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_gingivalis_w83_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_gingivalis_w83_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["242619"]),
        None,
        Some("."),
        Some("PG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodopirellula baltica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243090.32471045";
/// let this_library_node_name2 = "243090.RB9999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodopirellula_baltica_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodopirellula_baltica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodopirellula_baltica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodopirellula_baltica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243090"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidithiobacillus ferrooxidans ATCC23270 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243159.AFE_0001";
/// let this_library_node_name2 = "243159.AFE_3309";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidithiobacillus_ferrooxidans_atcc23270_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidithiobacillus_ferrooxidans_atcc23270_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidithiobacillus_ferrooxidans_atcc23270_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidithiobacillus_ferrooxidans_atcc23270_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243159"]),
        None,
        Some("."),
        Some("AFE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia mallei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243160.BMA0001";
/// let this_library_node_name2 = "243160.BMAA2118";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_mallei_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_mallei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_mallei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_mallei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243160"]),
        None,
        Some("."),
        Some("BMA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydia muridarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243161.TC_0001";
/// let this_library_node_name2 = "243161.TC_A07";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydia_muridarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydia_muridarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydia_muridarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydia_muridarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243161"]),
        None,
        Some("."),
        Some("TC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dehalococcoides mccartyi 195 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243164.DET0001";
/// let this_library_node_name2 = "243164.DET1642";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dehalococcoides_mccartyi_195_node_name(this_library_node_name1));
/// assert!(is_valid_string_dehalococcoides_mccartyi_195_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dehalococcoides_mccartyi_195_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dehalococcoides_mccartyi_195_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243164"]),
        None,
        Some("."),
        Some("DET"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus radiodurans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243230.DR_0001";
/// let this_library_node_name2 = "243230.DR_A0369";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_radiodurans_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_radiodurans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_radiodurans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_radiodurans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243230"]),
        None,
        Some("."),
        Some("DR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacter sulfurreducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243231.GSU0000.1";
/// let this_library_node_name2 = "243231.GSU3630";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacter_sulfurreducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacter_sulfurreducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacter_sulfurreducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacter_sulfurreducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243231"]),
        None,
        Some("."),
        Some("GSU"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanocaldococcus jannaschii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243232.MJ_0001";
/// let this_library_node_name2 = "243232.MJ_ECS12";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanocaldococcus_jannaschii_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanocaldococcus_jannaschii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanocaldococcus_jannaschii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanocaldococcus_jannaschii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243232"]),
        None,
        Some("."),
        Some("MJ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylococcus capsulatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243233.MCA0001";
/// let this_library_node_name2 = "243233.MCA3113";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylococcus_capsulatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylococcus_capsulatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylococcus_capsulatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylococcus_capsulatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243233"]),
        None,
        Some("."),
        Some("MCA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photorhabdus luminescens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243265.plu0001";
/// let this_library_node_name2 = "243265.plu4909";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photorhabdus_luminescens_node_name(this_library_node_name1));
/// assert!(is_valid_string_photorhabdus_luminescens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photorhabdus_luminescens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photorhabdus_luminescens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243265"]),
        None,
        Some("."),
        Some("plu"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma arthritidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243272.MARTH_orf001";
/// let this_library_node_name2 = "243272.MARTH_orf883";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_arthritidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_arthritidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_arthritidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_arthritidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243272"]),
        None,
        Some("."),
        Some("MARTH_orf"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma genitalium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243273.MG_001";
/// let this_library_node_name2 = "243273.MG_526";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_genitalium_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_genitalium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_genitalium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_genitalium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243273"]),
        None,
        Some("."),
        Some("MG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermotoga maritima nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243274.THEMA_00005";
/// let this_library_node_name2 = "243274.THEMA_09715";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermotoga_maritima_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermotoga_maritima_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermotoga_maritima_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermotoga_maritima_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243274"]),
        None,
        Some("."),
        Some("THEMA_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema denticola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243275.TDE_0001";
/// let this_library_node_name2 = "243275.TDE_2786";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_denticola_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_denticola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_denticola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_denticola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243275"]),
        None,
        Some("."),
        Some("TDE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema pallidum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243276.TPANIC_0001";
/// let this_library_node_name2 = "243276.TPANIC_1041";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_pallidum_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_pallidum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_pallidum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_pallidum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243276"]),
        None,
        Some("."),
        Some("TPANIC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio cholerae O1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243277.VC_0001";
/// let this_library_node_name2 = "243277.VC_A1115";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_cholerae_o1_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_cholerae_o1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_cholerae_o1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_cholerae_o1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243277"]),
        None,
        Some("."),
        Some("VC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chromobacterium violaceum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243365.CV_0001";
/// let this_library_node_name2 = "243365.CV_4407";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chromobacterium_violaceum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chromobacterium_violaceum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chromobacterium_violaceum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chromobacterium_violaceum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243365"]),
        None,
        Some("."),
        Some("CV_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas lutea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "243924.LT42_00030";
/// let this_library_node_name2 = "243924.LT42_25530";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_lutea_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_lutea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_lutea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_lutea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["243924"]),
        None,
        Some("."),
        Some("LT42_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cynoglossus semilaevis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "244447.XP_008305278.1";
/// let this_library_node_name2 = "244447.XP_008336891.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cynoglossus_semilaevis_node_name(this_library_node_name1));
/// assert!(is_valid_string_cynoglossus_semilaevis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cynoglossus_semilaevis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cynoglossus_semilaevis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["244447"]),
        None,
        Some("."),
        Some("XP_0083"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caedibacter acanthamoebae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "244581.IM40_00005";
/// let this_library_node_name2 = "244581.IM40_09915";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caedibacter_acanthamoebae_node_name(this_library_node_name1));
/// assert!(is_valid_string_caedibacter_acanthamoebae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caedibacter_acanthamoebae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caedibacter_acanthamoebae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["244581"]),
        None,
        Some("."),
        Some("IM40_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracaedibacter symbiosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "244582.JQAK01000001_gene1000";
/// let this_library_node_name2 = "244582.JQAK01000050_gene2511";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracaedibacter_symbiosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracaedibacter_symbiosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracaedibacter_symbiosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracaedibacter_symbiosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["244582"]),
        None,
        Some("."),
        Some("JQAK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wallemia ichthyophaga nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "245174.XP_009265674.1";
/// let this_library_node_name2 = "245174.XP_009270536.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wallemia_ichthyophaga_node_name(this_library_node_name1));
/// assert!(is_valid_string_wallemia_ichthyophaga_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wallemia_ichthyophaga_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wallemia_ichthyophaga_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["245174"]),
        None,
        Some("."),
        Some("XP_0092"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carboxydothermus hydrogenoformans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "246194.CHY_0001";
/// let this_library_node_name2 = "246194.CHY_2710";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carboxydothermus_hydrogenoformans_node_name(this_library_node_name1));
/// assert!(is_valid_string_carboxydothermus_hydrogenoformans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carboxydothermus_hydrogenoformans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carboxydothermus_hydrogenoformans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["246194"]),
        None,
        Some("."),
        Some("CHY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dichelobacter nodosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "246195.DNO_0001";
/// let this_library_node_name2 = "246195.DNO_1354";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dichelobacter_nodosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_dichelobacter_nodosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dichelobacter_nodosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dichelobacter_nodosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["246195"]),
        None,
        Some("."),
        Some("DNO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium smegmatis MC2155 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "246196.MSMEI_0001";
/// let this_library_node_name2 = "246196.MSMEI_6752";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_smegmatis_mc2155_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_smegmatis_mc2155_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_smegmatis_mc2155_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_smegmatis_mc2155_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["246196"]),
        None,
        Some("."),
        Some("MSMEI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myxococcus xanthus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "246197.MXAN_0001";
/// let this_library_node_name2 = "246197.MXAN_7517";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myxococcus_xanthus_node_name(this_library_node_name1));
/// assert!(is_valid_string_myxococcus_xanthus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myxococcus_xanthus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myxococcus_xanthus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["246197"]),
        None,
        Some("."),
        Some("MXAN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus albus 8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "246199.CUS_4251";
/// let this_library_node_name2 = "246199.CUS_8160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_albus_8_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_albus_8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_albus_8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_albus_8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["246199"]),
        None,
        Some("."),
        Some("CUS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruegeria pomeroyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "246200.SPO0001";
/// let this_library_node_name2 = "246200.SPOA0452";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruegeria_pomeroyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruegeria_pomeroyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruegeria_pomeroyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruegeria_pomeroyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["246200"]),
        None,
        Some("."),
        Some("SPO"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis NCTC 12261 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "246201.SM12261_0001";
/// let this_library_node_name2 = "246201.SM12261_1641";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_nctc_12261_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_nctc_12261_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_nctc_12261_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_nctc_12261_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["246201"]),
        None,
        Some("."),
        Some("SM12261_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tupaia chinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "246437.XP_006139771.1";
/// let this_library_node_name2 = "246437.XP_006172492.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tupaia_chinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_tupaia_chinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tupaia_chinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tupaia_chinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["246437"]),
        None,
        Some("."),
        Some("XP_0061"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermococcus sp. AM4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "246969.TAM4_1";
/// let this_library_node_name2 = "246969.TAM4_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermococcus_sp_am4_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermococcus_sp_am4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermococcus_sp_am4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermococcus_sp_am4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["246969"]),
        None,
        Some("."),
        Some("TAM4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia farcinica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "247156.NFA_10";
/// let this_library_node_name2 = "247156.PNF1_990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_farcinica_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_farcinica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_farcinica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_farcinica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["247156"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING planctomycete KSU1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "247490.KSU1_A0001";
/// let this_library_node_name2 = "247490.KSU1_D1058";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_planctomycete_ksu1_node_name(this_library_node_name1));
/// assert!(is_valid_string_planctomycete_ksu1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_planctomycete_ksu1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_planctomycete_ksu1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["247490"]),
        None,
        Some("."),
        Some("KSU1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium HTCC2143 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "247633.GP2143_00005";
/// let this_library_node_name2 = "247633.GP2143_18400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_htcc2143_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_htcc2143_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_htcc2143_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_htcc2143_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["247633"]),
        None,
        Some("."),
        Some("GP2143_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium HTCC2148 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "247634.GPB2148_1";
/// let this_library_node_name2 = "247634.GPB2148_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_htcc2148_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_htcc2148_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_htcc2148_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_htcc2148_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["247634"]),
        None,
        Some("."),
        Some("GPB2148_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium HTCC2080 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "247639.MGP2080_00005";
/// let this_library_node_name2 = "247639.MGP2080_15999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_htcc2080_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_htcc2080_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_htcc2080_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_htcc2080_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["247639"]),
        None,
        Some("."),
        Some("MGP2080_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coccomyxa subellipsoidea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "248742.XP_005642550.1";
/// let this_library_node_name2 = "248742.XP_005652388.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coccomyxa_subellipsoidea_node_name(this_library_node_name1));
/// assert!(is_valid_string_coccomyxa_subellipsoidea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coccomyxa_subellipsoidea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coccomyxa_subellipsoidea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["248742"]),
        None,
        Some("."),
        Some("XP_0056"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gloeobacter violaceus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "251221.35210561";
/// let this_library_node_name2 = "251221.35215005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gloeobacter_violaceus_node_name(this_library_node_name1));
/// assert!(is_valid_string_gloeobacter_violaceus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gloeobacter_violaceus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gloeobacter_violaceus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["251221"]),
        None,
        Some("."),
        Some("3521"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chroococcidiopsis thermalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "251229.Chro_0001";
/// let this_library_node_name2 = "251229.Chro_R0033";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chroococcidiopsis_thermalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_chroococcidiopsis_thermalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chroococcidiopsis_thermalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chroococcidiopsis_thermalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["251229"]),
        None,
        Some("."),
        Some("Chro_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanicola batsensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "252305.OB2597_00005";
/// let this_library_node_name2 = "252305.OB2597_16947";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanicola_batsensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanicola_batsensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanicola_batsensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanicola_batsensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["252305"]),
        None,
        Some("."),
        Some("OB2597_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. C nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "253839.SSNG_00001";
/// let this_library_node_name2 = "253839.SSNG_07540";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_c_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_c_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_c_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_c_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["253839"]),
        None,
        Some("."),
        Some("SSNG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ehrlichia ruminantium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "254945.Erum0010";
/// let this_library_node_name2 = "254945.Erum8930";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ehrlichia_ruminantium_node_name(this_library_node_name1));
/// assert!(is_valid_string_ehrlichia_ruminantium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ehrlichia_ruminantium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ehrlichia_ruminantium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["254945"]),
        None,
        Some("."),
        Some("Erum"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dehalococcoides mccartyi CBDB1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "255470.cbdbA1";
/// let this_library_node_name2 = "255470.cbdbC1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dehalococcoides_mccartyi_cbdb1_node_name(this_library_node_name1));
/// assert!(is_valid_string_dehalococcoides_mccartyi_cbdb1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dehalococcoides_mccartyi_cbdb1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dehalococcoides_mccartyi_cbdb1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["255470"]),
        None,
        Some("."),
        Some("cbdb"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bordetella bronchiseptica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "257310.BB0001";
/// let this_library_node_name2 = "257310.BB5013";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bordetella_bronchiseptica_node_name(this_library_node_name1));
/// assert!(is_valid_string_bordetella_bronchiseptica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bordetella_bronchiseptica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bordetella_bronchiseptica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["257310"]),
        None,
        Some("."),
        Some("BB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bordetella pertussis Tohama nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "257313.BP0001";
/// let this_library_node_name2 = "257313.BP3871";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bordetella_pertussis_tohama_node_name(this_library_node_name1));
/// assert!(is_valid_string_bordetella_pertussis_tohama_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bordetella_pertussis_tohama_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bordetella_pertussis_tohama_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["257313"]),
        None,
        Some("."),
        Some("BP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus johnsonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "257314.LJ_0001";
/// let this_library_node_name2 = "257314.LJ_1857";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_johnsonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_johnsonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_johnsonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_johnsonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["257314"]),
        None,
        Some("."),
        Some("LJ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia typhi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "257363.RT0001";
/// let this_library_node_name2 = "257363.RT0877";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_typhi_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_typhi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_typhi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_typhi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["257363"]),
        None,
        Some("."),
        Some("RT0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kitasatospora arboriphila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "258052.JNYV01000001_gene10";
/// let this_library_node_name2 = "258052.JNYV01000045_gene736";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kitasatospora_arboriphila_node_name(this_library_node_name1));
/// assert!(is_valid_string_kitasatospora_arboriphila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kitasatospora_arboriphila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kitasatospora_arboriphila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["258052"]),
        None,
        Some("."),
        Some("JNYV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium cosmeticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "258533.BN977_00001";
/// let this_library_node_name2 = "258533.BN977_06356";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_cosmeticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_cosmeticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_cosmeticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_cosmeticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["258533"]),
        None,
        Some("."),
        Some("BN977_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodopseudomonas palustris CGA009 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "258594.RPA0001";
/// let this_library_node_name2 = "258594.pRPA7";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodopseudomonas_palustris_cga009_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodopseudomonas_palustris_cga009_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodopseudomonas_palustris_cga009_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodopseudomonas_palustris_cga009_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["258594"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter arcticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "259536.Psyc_0001";
/// let this_library_node_name2 = "259536.Psyc_2147";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_arcticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_arcticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_arcticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_arcticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["259536"]),
        None,
        Some("."),
        Some("Psyc_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus anthracis Sterne nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "260799.BAS0001";
/// let this_library_node_name2 = "260799.BAS5341";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_anthracis_sterne_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_anthracis_sterne_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_anthracis_sterne_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_anthracis_sterne_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["260799"]),
        None,
        Some("."),
        Some("BAS"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosomonas sp. Is79A3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "261292.Nit79A3_0001";
/// let this_library_node_name2 = "261292.Nit79A3_3561";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosomonas_sp_is79a3_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosomonas_sp_is79a3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosomonas_sp_is79a3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosomonas_sp_is79a3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["261292"]),
        None,
        Some("."),
        Some("Nit79A3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Buchnera aphidicola Ctu nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "261317.BCTU_001";
/// let this_library_node_name2 = "261317.BCTU_404";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_buchnera_aphidicola_ctu_node_name(this_library_node_name1));
/// assert!(is_valid_string_buchnera_aphidicola_ctu_node_name(this_library_node_name2));
/// assert!(!is_valid_string_buchnera_aphidicola_ctu_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_buchnera_aphidicola_ctu_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["261317"]),
        None,
        Some("."),
        Some("BCTU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium avium paratuberculosis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "262316.MAP_0001";
/// let this_library_node_name2 = "262316.MAP_4350c";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_avium_paratuberculosis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_avium_paratuberculosis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_avium_paratuberculosis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_avium_paratuberculosis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["262316"]),
        None,
        Some("."),
        Some("MAP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Exiguobacterium sibiricum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "262543.Exig_0001";
/// let this_library_node_name2 = "262543.Exig_3058";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_exiguobacterium_sibiricum_node_name(this_library_node_name1));
/// assert!(is_valid_string_exiguobacterium_sibiricum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_exiguobacterium_sibiricum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_exiguobacterium_sibiricum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["262543"]),
        None,
        Some("."),
        Some("Exig_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma hyopneumoniae J nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "262719.MHJ_0001";
/// let this_library_node_name2 = "262719.MHJ_0699";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_hyopneumoniae_j_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_hyopneumoniae_j_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_hyopneumoniae_j_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_hyopneumoniae_j_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["262719"]),
        None,
        Some("."),
        Some("MHJ_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma synoviae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "262723.MS53_0001";
/// let this_library_node_name2 = "262723.MS53_0714";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_synoviae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_synoviae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_synoviae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_synoviae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["262723"]),
        None,
        Some("."),
        Some("MS53_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus thermophilus HB27 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "262724.TT_C0001";
/// let this_library_node_name2 = "262724.TT_P0230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_thermophilus_hb27_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_thermophilus_hb27_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_thermophilus_hb27_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_thermophilus_hb27_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["262724"]),
        None,
        Some("."),
        Some("TT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytoplasma onion yellows nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "262768.PAM_001";
/// let this_library_node_name2 = "262768.PAM_765";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytoplasma_onion_yellows_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytoplasma_onion_yellows_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytoplasma_onion_yellows_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytoplasma_onion_yellows_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["262768"]),
        None,
        Some("."),
        Some("PAM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Verrucosispora maris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "263358.VAB18032_00005";
/// let this_library_node_name2 = "263358.VAB18032_30359";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_verrucosispora_maris_node_name(this_library_node_name1));
/// assert!(is_valid_string_verrucosispora_maris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_verrucosispora_maris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_verrucosispora_maris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["263358"]),
        None,
        Some("."),
        Some("VAB18032_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pneumocystis murina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "263815.XP_007871851.1";
/// let this_library_node_name2 = "263815.XP_007875688.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pneumocystis_murina_node_name(this_library_node_name1));
/// assert!(is_valid_string_pneumocystis_murina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pneumocystis_murina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pneumocystis_murina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["263815"]),
        None,
        Some("."),
        Some("XP_00787"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Picrophilus torridus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "263820.PTO0001";
/// let this_library_node_name2 = "263820.PTO1535";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_picrophilus_torridus_node_name(this_library_node_name1));
/// assert!(is_valid_string_picrophilus_torridus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_picrophilus_torridus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_picrophilus_torridus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["263820"]),
        None,
        Some("."),
        Some("PTO"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ralstonia eutropha JMP134 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264198.Reut_A0001";
/// let this_library_node_name2 = "264198.Reut_C6440";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ralstonia_eutropha_jmp134_node_name(this_library_node_name1));
/// assert!(is_valid_string_ralstonia_eutropha_jmp134_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ralstonia_eutropha_jmp134_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ralstonia_eutropha_jmp134_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264198"]),
        None,
        Some("."),
        Some("Reut_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus thermophilus LMG18311 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264199.stu0001";
/// let this_library_node_name2 = "264199.stu2025";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_thermophilus_lmg18311_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_thermophilus_lmg18311_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_thermophilus_lmg18311_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_thermophilus_lmg18311_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264199"]),
        None,
        Some("."),
        Some("stu"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Protochlamydia amoebophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264201.pc0001";
/// let this_library_node_name2 = "264201.pc2031";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_protochlamydia_amoebophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_protochlamydia_amoebophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_protochlamydia_amoebophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_protochlamydia_amoebophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264201"]),
        None,
        Some("."),
        Some("pc"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydophila felis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264202.89331180";
/// let this_library_node_name2 = "264202.CF1005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydophila_felis_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydophila_felis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydophila_felis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydophila_felis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264202"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zymomonas mobilis ZM4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264203.ZMO0001";
/// let this_library_node_name2 = "264203.ZMO2039";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zymomonas_mobilis_zm4_node_name(this_library_node_name1));
/// assert!(is_valid_string_zymomonas_mobilis_zm4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zymomonas_mobilis_zm4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zymomonas_mobilis_zm4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264203"]),
        None,
        Some("."),
        Some("ZMO"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capsella grandiflora nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264402.Cagra.0001s0001.1.p";
/// let this_library_node_name2 = "264402.Cagra.9972s0001.1.p";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capsella_grandiflora_node_name(this_library_node_name1));
/// assert!(is_valid_string_capsella_grandiflora_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capsella_grandiflora_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capsella_grandiflora_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264402"]),
        None,
        Some("."),
        Some("Cagra"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bdellovibrio bacteriovorus HD100 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264462.Bd0001";
/// let this_library_node_name2 = "264462.Bd3913";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bdellovibrio_bacteriovorus_hd100_node_name(this_library_node_name1));
/// assert!(is_valid_string_bdellovibrio_bacteriovorus_hd100_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bdellovibrio_bacteriovorus_hd100_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bdellovibrio_bacteriovorus_hd100_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264462"]),
        None,
        Some("."),
        Some("Bd"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas syringae phaseolicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264730.PSPPH_0001";
/// let this_library_node_name2 = "264730.PSPPH_A0149";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_syringae_phaseolicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_syringae_phaseolicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_syringae_phaseolicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_syringae_phaseolicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264730"]),
        None,
        Some("."),
        Some("PSPPH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella ruminicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264731.PRU_0001";
/// let this_library_node_name2 = "264731.PRU_2943";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_ruminicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_ruminicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_ruminicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_ruminicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264731"]),
        None,
        Some("."),
        Some("PRU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moorella thermoacetica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264732.Moth_0001";
/// let this_library_node_name2 = "264732.Moth_2523";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moorella_thermoacetica_node_name(this_library_node_name1));
/// assert!(is_valid_string_moorella_thermoacetica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moorella_thermoacetica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moorella_thermoacetica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264732"]),
        None,
        Some("."),
        Some("Moth_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Byssochlamys spectabilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "264951.V5F6T3";
/// let this_library_node_name2 = "264951.V5I690";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_byssochlamys_spectabilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_byssochlamys_spectabilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_byssochlamys_spectabilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_byssochlamys_spectabilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["264951"]),
        None,
        Some("."),
        Some("V5"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacillus flagellatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "265072.Mfla_0001";
/// let this_library_node_name2 = "265072.Mfla_2761";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacillus_flagellatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacillus_flagellatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacillus_flagellatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacillus_flagellatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["265072"]),
        None,
        Some("."),
        Some("Mfla_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesoplasma florum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "265311.Mfl001";
/// let this_library_node_name2 = "265311.Mfl686";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesoplasma_florum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesoplasma_florum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesoplasma_florum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesoplasma_florum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["265311"]),
        None,
        Some("."),
        Some("Mfl"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus cibi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "265729.GS18_0200010";
/// let this_library_node_name2 = "265729.GS18_0221835";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_cibi_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_cibi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_cibi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_cibi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["265729"]),
        None,
        Some("."),
        Some("GS18_02"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rubrobacter xylanophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "266117.Rxyl_0001";
/// let this_library_node_name2 = "266117.Rxyl_3217";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rubrobacter_xylanophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rubrobacter_xylanophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rubrobacter_xylanophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rubrobacter_xylanophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["266117"]),
        None,
        Some("."),
        Some("Rxyl_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cupriavidus metallidurans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "266264.Rmet_0001";
/// let this_library_node_name2 = "266264.Rmet_6771";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cupriavidus_metallidurans_node_name(this_library_node_name1));
/// assert!(is_valid_string_cupriavidus_metallidurans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cupriavidus_metallidurans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cupriavidus_metallidurans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["266264"]),
        None,
        Some("."),
        Some("Rmet_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia xenovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "266265.Bxe_A0001";
/// let this_library_node_name2 = "266265.Bxe_C1392";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_xenovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_xenovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_xenovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_xenovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["266265"]),
        None,
        Some("."),
        Some("Bxe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium antarcticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "266748.HY04_00005";
/// let this_library_node_name2 = "266748.HY04_14870";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_antarcticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_antarcticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_antarcticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_antarcticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["266748"]),
        None,
        Some("."),
        Some("HY04_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas gingivicanis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "266762.HQ36_00010";
/// let this_library_node_name2 = "266762.HQ36_08860";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_gingivicanis_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_gingivicanis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_gingivicanis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_gingivicanis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["266762"]),
        None,
        Some("."),
        Some("HQ36_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chelativorans sp. BNC1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "266779.Meso_0001";
/// let this_library_node_name2 = "266779.Meso_4562";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chelativorans_sp_bnc1_node_name(this_library_node_name1));
/// assert!(is_valid_string_chelativorans_sp_bnc1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chelativorans_sp_bnc1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chelativorans_sp_bnc1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["266779"]),
        None,
        Some("."),
        Some("Meso_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thalassobacter stenotrophicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "266809.PM03_00010";
/// let this_library_node_name2 = "266809.PM03_16790";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thalassobacter_stenotrophicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thalassobacter_stenotrophicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thalassobacter_stenotrophicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thalassobacter_stenotrophicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["266809"]),
        None,
        Some("."),
        Some("PM03_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sinorhizobium meliloti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "266834.SM_b20002";
/// let this_library_node_name2 = "266834.SMc05020";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sinorhizobium_meliloti_node_name(this_library_node_name1));
/// assert!(is_valid_string_sinorhizobium_meliloti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sinorhizobium_meliloti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sinorhizobium_meliloti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["266834"]),
        None,
        Some("."),
        Some("SM"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium loti MAFF303099 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "266835.14021069";
/// let this_library_node_name2 = "266835.14028333";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_loti_maff303099_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_loti_maff303099_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_loti_maff303099_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_loti_maff303099_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["266835"]),
        None,
        Some("."),
        Some("1402"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kineococcus radiotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "266940.Krad_0001";
/// let this_library_node_name2 = "266940.Krad_4715";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kineococcus_radiotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_kineococcus_radiotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kineococcus_radiotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kineococcus_radiotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["266940"]),
        None,
        Some("."),
        Some("Krad_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanococcus maripaludis S2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "267377.MMP0001";
/// let this_library_node_name2 = "267377.MMP1722";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanococcus_maripaludis_s2_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanococcus_maripaludis_s2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanococcus_maripaludis_s2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanococcus_maripaludis_s2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["267377"]),
        None,
        Some("."),
        Some("MMP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ralstonia solanacearum GMI1000 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "267608.RSc0001";
/// let this_library_node_name2 = "267608.RSp1678";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ralstonia_solanacearum_gmi1000_node_name(this_library_node_name1));
/// assert!(is_valid_string_ralstonia_solanacearum_gmi1000_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ralstonia_solanacearum_gmi1000_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ralstonia_solanacearum_gmi1000_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["267608"]),
        None,
        Some("."),
        Some("RS"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium acnes KPA171202 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "267747.PPA0001";
/// let this_library_node_name2 = "267747.PPA2407";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_acnes_kpa171202_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_acnes_kpa171202_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_acnes_kpa171202_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_acnes_kpa171202_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["267747"]),
        None,
        Some("."),
        Some("PPA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma mobile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "267748.MMOB0010";
/// let this_library_node_name2 = "267748.MMOB6330";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_mobile_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_mobile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_mobile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_mobile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["267748"]),
        None,
        Some("."),
        Some("MMOB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus wynnii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "268407.PWYN_00025";
/// let this_library_node_name2 = "268407.PWYN_28630";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_wynnii_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_wynnii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_wynnii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_wynnii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["268407"]),
        None,
        Some("."),
        Some("PWYN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natronomonas moolapensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "268739.Nmlp_1001";
/// let this_library_node_name2 = "268739.Nmlp_3948";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natronomonas_moolapensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_natronomonas_moolapensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natronomonas_moolapensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natronomonas_moolapensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["268739"]),
        None,
        Some("."),
        Some("Nmlp_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus elongatus PCC6301 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "269084.syc0001_c";
/// let this_library_node_name2 = "269084.syc2525_c";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_elongatus_pcc6301_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_elongatus_pcc6301_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_elongatus_pcc6301_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_elongatus_pcc6301_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["269084"]),
        None,
        Some("."),
        Some("syc"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia vietnamiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "269482.Bcep1808_0001";
/// let this_library_node_name2 = "269482.Bcep1808_7664";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_vietnamiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_vietnamiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_vietnamiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_vietnamiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["269482"]),
        None,
        Some("."),
        Some("Bcep1808_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ehrlichia canis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "269484.Ecaj_0001";
/// let this_library_node_name2 = "269484.Ecaj_0945";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ehrlichia_canis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ehrlichia_canis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ehrlichia_canis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ehrlichia_canis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["269484"]),
        None,
        Some("."),
        Some("Ecaj_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodospirillum rubrum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "269796.Rru_A0001";
/// let this_library_node_name2 = "269796.Rru_A3802";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodospirillum_rubrum_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodospirillum_rubrum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodospirillum_rubrum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodospirillum_rubrum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["269796"]),
        None,
        Some("."),
        Some("Rru_A"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanosarcina barkeri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "269797.Mbar_A0001";
/// let this_library_node_name2 = "269797.Mbar_B3760";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanosarcina_barkeri_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanosarcina_barkeri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanosarcina_barkeri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanosarcina_barkeri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["269797"]),
        None,
        Some("."),
        Some("Mbar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cytophaga hutchinsonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "269798.CHU_0001";
/// let this_library_node_name2 = "269798.CHU_3844";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cytophaga_hutchinsonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_cytophaga_hutchinsonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cytophaga_hutchinsonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cytophaga_hutchinsonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["269798"]),
        None,
        Some("."),
        Some("CHU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacter metallireducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "269799.Gmet_0001";
/// let this_library_node_name2 = "269799.Gmet_A3644";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacter_metallireducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacter_metallireducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacter_metallireducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacter_metallireducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["269799"]),
        None,
        Some("."),
        Some("Gmet_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermobifida fusca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "269800.Tfu_0001";
/// let this_library_node_name2 = "269800.Tfu_3117";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermobifida_fusca_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermobifida_fusca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermobifida_fusca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermobifida_fusca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["269800"]),
        None,
        Some("."),
        Some("Tfu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter sp. ELB17 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "270374.MELB17_00005";
/// let this_library_node_name2 = "270374.MELB17_24352";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_sp_elb17_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_sp_elb17_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_sp_elb17_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_sp_elb17_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["270374"]),
        None,
        Some("."),
        Some("MELB17_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anabaena cylindrica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272123.Anacy_0001";
/// let this_library_node_name2 = "272123.Anacy_R0021";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anabaena_cylindrica_node_name(this_library_node_name1));
/// assert!(is_valid_string_anabaena_cylindrica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anabaena_cylindrica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anabaena_cylindrica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272123"]),
        None,
        Some("."),
        Some("Anacy_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptolyngbya boryana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272134.KB731324_gene1000";
/// let this_library_node_name2 = "272134.KB731328_gene846";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptolyngbya_boryana_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptolyngbya_boryana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptolyngbya_boryana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptolyngbya_boryana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272134"]),
        None,
        Some("."),
        Some("KB73132"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aggregatibacter actinomycetemcomitans HK1651 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272556.CF65_00002";
/// let this_library_node_name2 = "272556.CF65_03016";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aggregatibacter_actinomycetemcomitans_hk1651_node_name(this_library_node_name1));
/// assert!(is_valid_string_aggregatibacter_actinomycetemcomitans_hk1651_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aggregatibacter_actinomycetemcomitans_hk1651_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aggregatibacter_actinomycetemcomitans_hk1651_node_name(
    node_name: &str,
) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272556"]),
        None,
        Some("."),
        Some("CF65_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aeropyrum pernix nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272557.APE_0001";
/// let this_library_node_name2 = "272557.APE_2617e.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aeropyrum_pernix_node_name(this_library_node_name1));
/// assert!(is_valid_string_aeropyrum_pernix_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aeropyrum_pernix_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aeropyrum_pernix_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272557"]),
        None,
        Some("."),
        Some("APE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus halodurans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272558.10172613";
/// let this_library_node_name2 = "272558.12641880";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_halodurans_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_halodurans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_halodurans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_halodurans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272558"]),
        None,
        Some("."),
        Some("1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides fragilis NCTC 9343 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272559.BF9343_0001";
/// let this_library_node_name2 = "272559.BF9343_p48";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_fragilis_nctc_9343_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_fragilis_nctc_9343_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_fragilis_nctc_9343_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_fragilis_nctc_9343_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272559"]),
        None,
        Some("."),
        Some("BF9343_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia pseudomallei K96243 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272560.BPSL0001";
/// let this_library_node_name2 = "272560.BPSS2351";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_pseudomallei_k96243_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_pseudomallei_k96243_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_pseudomallei_k96243_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_pseudomallei_k96243_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272560"]),
        None,
        Some("."),
        Some("BPS"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium acetobutylicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272562.CA_C0001";
/// let this_library_node_name2 = "272562.CA_C3739";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_acetobutylicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_acetobutylicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_acetobutylicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_acetobutylicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272562"]),
        None,
        Some("."),
        Some("CA_C"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoclostridium difficile 630 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272563.CD630_00010";
/// let this_library_node_name2 = "272563.CD630_36800";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoclostridium_difficile_630_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoclostridium_difficile_630_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoclostridium_difficile_630_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoclostridium_difficile_630_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272563"]),
        None,
        Some("."),
        Some("CD630_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gluconacetobacter diazotrophicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272568.GDI0002";
/// let this_library_node_name2 = "272568.GDI3938";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gluconacetobacter_diazotrophicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_gluconacetobacter_diazotrophicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gluconacetobacter_diazotrophicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gluconacetobacter_diazotrophicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272568"]),
        None,
        Some("."),
        Some("GDI"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloarcula marismortui nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272569.pNG4001";
/// let this_library_node_name2 = "272569.rrnB0336";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloarcula_marismortui_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloarcula_marismortui_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloarcula_marismortui_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloarcula_marismortui_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272569"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus acidophilus NCFM nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272621.LBA0001";
/// let this_library_node_name2 = "272621.LBA1979";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_acidophilus_ncfm_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_acidophilus_ncfm_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_acidophilus_ncfm_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_acidophilus_ncfm_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272621"]),
        None,
        Some("."),
        Some("LBA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactococcus lactis Il1403 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272623.L0001";
/// let this_library_node_name2 = "272623.L99912";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactococcus_lactis_il1403_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactococcus_lactis_il1403_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactococcus_lactis_il1403_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactococcus_lactis_il1403_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272623"]),
        None,
        Some("."),
        Some("L"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella pneumophila Philadelphia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272624.lpg0001";
/// let this_library_node_name2 = "272624.lpg3005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_pneumophila_philadelphia_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_pneumophila_philadelphia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_pneumophila_philadelphia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_pneumophila_philadelphia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272624"]),
        None,
        Some("."),
        Some("lpg"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeria innocua nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272626.lin0001";
/// let this_library_node_name2 = "272626.pli0080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeria_innocua_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeria_innocua_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeria_innocua_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeria_innocua_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272626"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium extorquens AM1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272630.MexAM1_META1p0001";
/// let this_library_node_name2 = "272630.MexAM1_p3METApCDS5359D";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_extorquens_am1_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_extorquens_am1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_extorquens_am1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_extorquens_am1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272630"]),
        None,
        Some("."),
        Some("MexAM1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium leprae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272631.ML0001";
/// let this_library_node_name2 = "272631.ML2713";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_leprae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_leprae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_leprae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_leprae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272631"]),
        None,
        Some("."),
        Some("ML"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma mycoides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272632.MSC_0001";
/// let this_library_node_name2 = "272632.MSC_1068";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_mycoides_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_mycoides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_mycoides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_mycoides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272632"]),
        None,
        Some("."),
        Some("MSC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma penetrans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272633.26453459";
/// let this_library_node_name2 = "272633.26454499";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_penetrans_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_penetrans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_penetrans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_penetrans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272633"]),
        None,
        Some("."),
        Some("2645"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma pulmonis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272635.15828699";
/// let this_library_node_name2 = "272635.MYPU_7820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_pulmonis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_pulmonis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_pulmonis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_pulmonis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272635"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrococcus abyssi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272844.PAB0004";
/// let this_library_node_name2 = "272844.pGT5_02";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrococcus_abyssi_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrococcus_abyssi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrococcus_abyssi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrococcus_abyssi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272844"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodobacter capsulatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272942.RCAP_rcc00001";
/// let this_library_node_name2 = "272942.RCAP_rcc03534";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodobacter_capsulatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodobacter_capsulatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodobacter_capsulatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodobacter_capsulatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272942"]),
        None,
        Some("."),
        Some("RCAP_rcc0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodobacter sphaeroides 241 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272943.RSP_0002";
/// let this_library_node_name2 = "272943.RSP_7647";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodobacter_sphaeroides_241_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodobacter_sphaeroides_241_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodobacter_sphaeroides_241_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodobacter_sphaeroides_241_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272943"]),
        None,
        Some("."),
        Some("RSP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia prowazekii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272947.RP001";
/// let this_library_node_name2 = "272947.RP885";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_prowazekii_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_prowazekii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_prowazekii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_prowazekii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272947"]),
        None,
        Some("."),
        Some("RP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia sibirica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272951.rsib_orf01";
/// let this_library_node_name2 = "272951.rsib_orf999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_sibirica_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_sibirica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_sibirica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_sibirica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272951"]),
        None,
        Some("."),
        Some("rsib_orf"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyaloperonospora arabidopsidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "272952.HpaP800000";
/// let this_library_node_name2 = "272952.HpaP814910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyaloperonospora_arabidopsidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyaloperonospora_arabidopsidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyaloperonospora_arabidopsidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyaloperonospora_arabidopsidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["272952"]),
        None,
        Some("."),
        Some("HpaP8"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfolobus solfataricus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "273057.SSO0001";
/// let this_library_node_name2 = "273057.SSO9953";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfolobus_solfataricus_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfolobus_solfataricus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfolobus_solfataricus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfolobus_solfataricus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["273057"]),
        None,
        Some("."),
        Some("SSO"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfolobus tokodaii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "273063.STK_00005";
/// let this_library_node_name2 = "273063.STK_26420";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfolobus_tokodaii_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfolobus_tokodaii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfolobus_tokodaii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfolobus_tokodaii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["273063"]),
        None,
        Some("."),
        Some("STK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldanaerobacter subterraneus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "273068.TTE0001";
/// let this_library_node_name2 = "273068.TTE2802";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldanaerobacter_subterraneus_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldanaerobacter_subterraneus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldanaerobacter_subterraneus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldanaerobacter_subterraneus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["273068"]),
        None,
        Some("."),
        Some("TTE"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoplasma acidophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "273075.Ta0001";
/// let this_library_node_name2 = "273075.Ta1610";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoplasma_acidophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoplasma_acidophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoplasma_acidophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoplasma_acidophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["273075"]),
        None,
        Some("."),
        Some("Ta"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoplasma volcanium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "273116.14324215";
/// let this_library_node_name2 = "273116.14325765";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoplasma_volcanium_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoplasma_volcanium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoplasma_volcanium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoplasma_volcanium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["273116"]),
        None,
        Some("."),
        Some("1432"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ureaplasma parvum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "273119.UU001";
/// let this_library_node_name2 = "273119.UU604";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ureaplasma_parvum_node_name(this_library_node_name1));
/// assert!(is_valid_string_ureaplasma_parvum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ureaplasma_parvum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ureaplasma_parvum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["273119"]),
        None,
        Some("."),
        Some("UU"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wolinella succinogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "273121.WS0000";
/// let this_library_node_name2 = "273121.WS2229";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wolinella_succinogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_wolinella_succinogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wolinella_succinogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wolinella_succinogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["273121"]),
        None,
        Some("."),
        Some("WS"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Candida orthopsilosis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "273371.XP_003865847.1";
/// let this_library_node_name2 = "273371.XP_003871525.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_candida_orthopsilosis_node_name(this_library_node_name1));
/// assert!(is_valid_string_candida_orthopsilosis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_candida_orthopsilosis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_candida_orthopsilosis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["273371"]),
        None,
        Some("."),
        Some("XP_0038"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia marcescens Db11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "273526.SMDB11_0001";
/// let this_library_node_name2 = "273526.SMDB11_4763";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_marcescens_db11_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_marcescens_db11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_marcescens_db11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_marcescens_db11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["273526"]),
        None,
        Some("."),
        Some("SMDB11_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium oleivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "273677.BW34_00003";
/// let this_library_node_name2 = "273677.BW34_02840";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_oleivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_oleivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_oleivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_oleivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["273677"]),
        None,
        Some("."),
        Some("BW34_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pediococcus pentosaceus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "278197.PEPE_0001";
/// let this_library_node_name2 = "278197.PEPE_1847";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pediococcus_pentosaceus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pediococcus_pentosaceus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pediococcus_pentosaceus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pediococcus_pentosaceus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["278197"]),
        None,
        Some("."),
        Some("PEPE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Diplosphaera colitermitum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "278957.ABEA03000001_gene4247";
/// let this_library_node_name2 = "278957.ABEA03000225_gene1570";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_diplosphaera_colitermitum_node_name(this_library_node_name1));
/// assert!(is_valid_string_diplosphaera_colitermitum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_diplosphaera_colitermitum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_diplosphaera_colitermitum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["278957"]),
        None,
        Some("."),
        Some("ABEA03000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidobacteriaceae bacterium TAA166 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "278963.ATWD01000001_gene1066";
/// let this_library_node_name2 = "278963.ATWD01000003_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidobacteriaceae_bacterium_taa166_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidobacteriaceae_bacterium_taa166_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidobacteriaceae_bacterium_taa166_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidobacteriaceae_bacterium_taa166_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["278963"]),
        None,
        Some("."),
        Some("ATWD0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus licheniformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "279010.BL00001";
/// let this_library_node_name2 = "279010.BL07084";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_licheniformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_licheniformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_licheniformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_licheniformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["279010"]),
        None,
        Some("."),
        Some("BL0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novosphingobium aromaticivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "279238.Saro_0001";
/// let this_library_node_name2 = "279238.Saro_3832";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novosphingobium_aromaticivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_novosphingobium_aromaticivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novosphingobium_aromaticivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novosphingobium_aromaticivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["279238"]),
        None,
        Some("."),
        Some("Saro_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudogulbenkiania ferrooxidans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "279714.FuraDRAFT_0001";
/// let this_library_node_name2 = "279714.FuraDRAFT_3927";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudogulbenkiania_ferrooxidans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudogulbenkiania_ferrooxidans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudogulbenkiania_ferrooxidans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudogulbenkiania_ferrooxidans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["279714"]),
        None,
        Some("."),
        Some("FuraDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus haemolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "279808.SH0001";
/// let this_library_node_name2 = "279808.pSHaeA03";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_haemolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_haemolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_haemolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_haemolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["279808"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leifsonia xyli CTCB07 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "281090.Lxx00010";
/// let this_library_node_name2 = "281090.Lxx25280";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leifsonia_xyli_ctcb07_node_name(this_library_node_name1));
/// assert!(is_valid_string_leifsonia_xyli_ctcb07_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leifsonia_xyli_ctcb07_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leifsonia_xyli_ctcb07_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["281090"]),
        None,
        Some("."),
        Some("Lxx"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caenorhabditis japonica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "281687.CJA00004";
/// let this_library_node_name2 = "281687.CJA46583";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caenorhabditis_japonica_node_name(this_library_node_name1));
/// assert!(is_valid_string_caenorhabditis_japonica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caenorhabditis_japonica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caenorhabditis_japonica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["281687"]),
        None,
        Some("."),
        Some("CJA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella quintana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "283165.BQ00010";
/// let this_library_node_name2 = "283165.BQ13580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_quintana_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_quintana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_quintana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_quintana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["283165"]),
        None,
        Some("."),
        Some("BQ"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella henselae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "283166.BH00010";
/// let this_library_node_name2 = "283166.BH16700";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_henselae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_henselae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_henselae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_henselae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["283166"]),
        None,
        Some("."),
        Some("BH"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas sp. Bsw20308 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "283699.D172_0001";
/// let this_library_node_name2 = "283699.D172_4172";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_sp_bsw20308_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_sp_bsw20308_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_sp_bsw20308_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_sp_bsw20308_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["283699"]),
        None,
        Some("."),
        Some("D172_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Idiomarina loihiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "283942.56178594";
/// let this_library_node_name2 = "283942.IL2640";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_idiomarina_loihiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_idiomarina_loihiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_idiomarina_loihiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_idiomarina_loihiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["283942"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces flavovariabilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "284031.JNXD01000001_gene4813";
/// let this_library_node_name2 = "284031.JNXD01000141_gene4806";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_flavovariabilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_flavovariabilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_flavovariabilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_flavovariabilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["284031"]),
        None,
        Some("."),
        Some("JNXD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces xylophagus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "285514.JNWO01000001_gene4075";
/// let this_library_node_name2 = "285514.JNWO01000211_gene938";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_xylophagus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_xylophagus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_xylophagus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_xylophagus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["285514"]),
        None,
        Some("."),
        Some("JNWO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces fulvoviolaceus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "285535.JOEY01000001_gene5112";
/// let this_library_node_name2 = "285535.JOEY01000263_gene821";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_fulvoviolaceus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_fulvoviolaceus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_fulvoviolaceus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_fulvoviolaceus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["285535"]),
        None,
        Some("."),
        Some("JOEY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolatopsis rifamycinica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "287986.DV20_00015";
/// let this_library_node_name2 = "287986.DV20_43590";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolatopsis_rifamycinica_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolatopsis_rifamycinica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolatopsis_rifamycinica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolatopsis_rifamycinica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["287986"]),
        None,
        Some("."),
        Some("DV20_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. BTAi1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "288000.BBta_0001";
/// let this_library_node_name2 = "288000.BBta_p0296";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_btai1_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_btai1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_btai1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_btai1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["288000"]),
        None,
        Some("."),
        Some("BBta_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Renibacterium salmoninarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "288705.RSal33209_0001";
/// let this_library_node_name2 = "288705.RSal33209_3558";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_renibacterium_salmoninarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_renibacterium_salmoninarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_renibacterium_salmoninarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_renibacterium_salmoninarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["288705"]),
        None,
        Some("."),
        Some("RSal33209_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermodesulfovibrio yellowstonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "289376.THEYE_A0001";
/// let this_library_node_name2 = "289376.THEYE_A2100";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermodesulfovibrio_yellowstonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermodesulfovibrio_yellowstonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermodesulfovibrio_yellowstonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermodesulfovibrio_yellowstonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["289376"]),
        None,
        Some("."),
        Some("THEYE_A"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermodesulfobacterium commune nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "289377.HL41_00015";
/// let this_library_node_name2 = "289377.HL41_09235";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermodesulfobacterium_commune_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermodesulfobacterium_commune_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermodesulfobacterium_commune_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermodesulfobacterium_commune_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["289377"]),
        None,
        Some("."),
        Some("HL41_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma bovis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "289397.MBOVPG45_0001";
/// let this_library_node_name2 = "289397.MBOVPG45_0902";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_bovis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_bovis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_bovis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_bovis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["289397"]),
        None,
        Some("."),
        Some("MBOVPG45_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorobium limicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290315.Clim_0001";
/// let this_library_node_name2 = "290315.Clim_2524";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorobium_limicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorobium_limicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorobium_limicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorobium_limicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290315"]),
        None,
        Some("."),
        Some("Clim_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorobium phaeobacteroides DSM266 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290317.Cpha266_0001";
/// let this_library_node_name2 = "290317.Cpha266_2743";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorobium_phaeobacteroides_dsm266_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorobium_phaeobacteroides_dsm266_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorobium_phaeobacteroides_dsm266_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorobium_phaeobacteroides_dsm266_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290317"]),
        None,
        Some("."),
        Some("Cpha266_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorobium phaeovibrioides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290318.Cvib_0001";
/// let this_library_node_name2 = "290318.Cvib_1774";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorobium_phaeovibrioides_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorobium_phaeovibrioides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorobium_phaeovibrioides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorobium_phaeovibrioides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290318"]),
        None,
        Some("."),
        Some("Cvib_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter aurescens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290340.AAur_0001";
/// let this_library_node_name2 = "290340.AAur_pTC20275";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_aurescens_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_aurescens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_aurescens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_aurescens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290340"]),
        None,
        Some("."),
        Some("AAur_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaeromyxobacter dehalogenans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290397.Adeh_0001";
/// let this_library_node_name2 = "290397.Adeh_4361";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaeromyxobacter_dehalogenans_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaeromyxobacter_dehalogenans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaeromyxobacter_dehalogenans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaeromyxobacter_dehalogenans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290397"]),
        None,
        Some("."),
        Some("Adeh_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chromohalobacter salexigens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290398.Csal_0001";
/// let this_library_node_name2 = "290398.Csal_3319";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chromohalobacter_salexigens_node_name(this_library_node_name1));
/// assert!(is_valid_string_chromohalobacter_salexigens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chromohalobacter_salexigens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chromohalobacter_salexigens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290398"]),
        None,
        Some("."),
        Some("Csal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. FB24 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290399.Arth_0001";
/// let this_library_node_name2 = "290399.Arth_4536";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_fb24_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_fb24_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_fb24_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_fb24_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290399"]),
        None,
        Some("."),
        Some("Arth_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Jannaschia sp. CCS1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290400.Jann_0001";
/// let this_library_node_name2 = "290400.Jann_4283";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_jannaschia_sp_ccs1_node_name(this_library_node_name1));
/// assert!(is_valid_string_jannaschia_sp_ccs1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_jannaschia_sp_ccs1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_jannaschia_sp_ccs1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290400"]),
        None,
        Some("."),
        Some("Jann_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium beijerinckii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290402.Cbei_0001";
/// let this_library_node_name2 = "290402.Cbei_5104";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_beijerinckii_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_beijerinckii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_beijerinckii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_beijerinckii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290402"]),
        None,
        Some("."),
        Some("Cbei_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia garinii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290434.BG0001";
/// let this_library_node_name2 = "290434.BGA74";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_garinii_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_garinii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_garinii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_garinii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290434"]),
        None,
        Some("."),
        Some("BG"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prosthecochloris aestuarii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290512.Paes_0001";
/// let this_library_node_name2 = "290512.Paes_2405";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prosthecochloris_aestuarii_node_name(this_library_node_name1));
/// assert!(is_valid_string_prosthecochloris_aestuarii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prosthecochloris_aestuarii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prosthecochloris_aestuarii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290512"]),
        None,
        Some("."),
        Some("Paes_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gluconobacter oxydans 621H nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "290633.GOX0001";
/// let this_library_node_name2 = "290633.GOX2666";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gluconobacter_oxydans_621h_node_name(this_library_node_name1));
/// assert!(is_valid_string_gluconobacter_oxydans_621h_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gluconobacter_oxydans_621h_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gluconobacter_oxydans_621h_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["290633"]),
        None,
        Some("."),
        Some("GOX"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photorhabdus asymbiotica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "291112.PAU_00001";
/// let this_library_node_name2 = "291112.PAU_pPAU1_0029";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photorhabdus_asymbiotica_node_name(this_library_node_name1));
/// assert!(is_valid_string_photorhabdus_asymbiotica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photorhabdus_asymbiotica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photorhabdus_asymbiotica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["291112"]),
        None,
        Some("."),
        Some("PAU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blochmannia pennsylvanicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "291272.BPEN_001";
/// let this_library_node_name2 = "291272.BPEN_657";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blochmannia_pennsylvanicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_blochmannia_pennsylvanicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blochmannia_pennsylvanicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blochmannia_pennsylvanicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["291272"]),
        None,
        Some("."),
        Some("BPEN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erythrobacter vulgaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "291985.CCSI01000001_gene1778";
/// let this_library_node_name2 = "291985.CCSI01000011_gene1038";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erythrobacter_vulgaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_erythrobacter_vulgaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erythrobacter_vulgaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erythrobacter_vulgaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["291985"]),
        None,
        Some("."),
        Some("CCSI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruegeria sp. TM1040 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "292414.TM1040_0001";
/// let this_library_node_name2 = "292414.TM1040_3875";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruegeria_sp_tm1040_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruegeria_sp_tm1040_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruegeria_sp_tm1040_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruegeria_sp_tm1040_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["292414"]),
        None,
        Some("."),
        Some("TM1040_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiobacillus denitrificans ATCC25259 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "292415.Tbd_0001";
/// let this_library_node_name2 = "292415.Tbd_2827";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiobacillus_denitrificans_atcc25259_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiobacillus_denitrificans_atcc25259_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiobacillus_denitrificans_atcc25259_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiobacillus_denitrificans_atcc25259_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["292415"]),
        None,
        Some("."),
        Some("Tbd_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Symbiobacterium thermophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "292459.STH1";
/// let this_library_node_name2 = "292459.STH999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_symbiobacterium_thermophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_symbiobacterium_thermophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_symbiobacterium_thermophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_symbiobacterium_thermophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["292459"]),
        None,
        Some("."),
        Some("STH"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanobacterium stanieri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "292563.Cyast_0001";
/// let this_library_node_name2 = "292563.Cyast_R0051";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanobacterium_stanieri_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanobacterium_stanieri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanobacterium_stanieri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanobacterium_stanieri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["292563"]),
        None,
        Some("."),
        Some("Cyast_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanobium gracile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "292564.Cyagr_0001";
/// let this_library_node_name2 = "292564.Cyagr_3441";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanobium_gracile_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanobium_gracile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanobium_gracile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanobium_gracile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["292564"]),
        None,
        Some("."),
        Some("Cyagr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wolbachia sp. Bma nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "292805.Wbm0001";
/// let this_library_node_name2 = "292805.Wbm0809";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wolbachia_sp_bma_node_name(this_library_node_name1));
/// assert!(is_valid_string_wolbachia_sp_bma_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wolbachia_sp_bma_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wolbachia_sp_bma_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["292805"]),
        None,
        Some("."),
        Some("Wbm0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyphellophora europaea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "293227.XP_008710532.1";
/// let this_library_node_name2 = "293227.XP_008721625.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyphellophora_europaea_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyphellophora_europaea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyphellophora_europaea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyphellophora_europaea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["293227"]),
        None,
        Some("."),
        Some("XP_0087"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia canadensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "293613.A1E_00005";
/// let this_library_node_name2 = "293613.A1E_05675";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_canadensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_canadensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_canadensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_canadensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["293613"]),
        None,
        Some("."),
        Some("A1E_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia akari nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "293614.A1C_00005";
/// let this_library_node_name2 = "293614.A1C_06880";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_akari_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_akari_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_akari_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_akari_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["293614"]),
        None,
        Some("."),
        Some("A1C_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alkaliphilus metalliredigens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "293826.Amet_0001";
/// let this_library_node_name2 = "293826.Amet_4802";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alkaliphilus_metalliredigens_node_name(this_library_node_name1));
/// assert!(is_valid_string_alkaliphilus_metalliredigens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alkaliphilus_metalliredigens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alkaliphilus_metalliredigens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["293826"]),
        None,
        Some("."),
        Some("Amet_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma hyopneumoniae 232 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "295358.mhp001";
/// let this_library_node_name2 = "295358.mhp699";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_hyopneumoniae_232_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_hyopneumoniae_232_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_hyopneumoniae_232_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_hyopneumoniae_232_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["295358"]),
        None,
        Some("."),
        Some("mhp"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Micromonas sp. RCC299 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "296587.XP_002499374.1";
/// let this_library_node_name2 = "296587.XP_002509418.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_micromonas_sp_rcc299_node_name(this_library_node_name1));
/// assert!(is_valid_string_micromonas_sp_rcc299_node_name(this_library_node_name2));
/// assert!(!is_valid_string_micromonas_sp_rcc299_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_micromonas_sp_rcc299_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["296587"]),
        None,
        Some("."),
        Some("XP_002"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polaromonas sp. JS666 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "296591.Bpro_0001";
/// let this_library_node_name2 = "296591.Bpro_5572";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polaromonas_sp_js666_node_name(this_library_node_name1));
/// assert!(is_valid_string_polaromonas_sp_js666_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polaromonas_sp_js666_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polaromonas_sp_js666_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["296591"]),
        None,
        Some("."),
        Some("Bpro_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella pneumophila Paris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "297246.lpp0001";
/// let this_library_node_name2 = "297246.plpp0140";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_pneumophila_paris_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_pneumophila_paris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_pneumophila_paris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_pneumophila_paris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["297246"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photobacterium profundum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "298386.PBPRA0001";
/// let this_library_node_name2 = "298386.PBPR_B2036";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photobacterium_profundum_node_name(this_library_node_name1));
/// assert!(is_valid_string_photobacterium_profundum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photobacterium_profundum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photobacterium_profundum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["298386"]),
        None,
        Some("."),
        Some("PBPR"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frankia sp. EAN1pec nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "298653.Franean1_0001";
/// let this_library_node_name2 = "298653.Franean1_7341";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frankia_sp_ean1pec_node_name(this_library_node_name1));
/// assert!(is_valid_string_frankia_sp_ean1pec_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frankia_sp_ean1pec_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frankia_sp_ean1pec_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["298653"]),
        None,
        Some("."),
        Some("Franean1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frankia sp. EuI1c nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "298654.FraEuI1c_0001";
/// let this_library_node_name2 = "298654.FraEuI1c_7207";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frankia_sp_eui1c_node_name(this_library_node_name1));
/// assert!(is_valid_string_frankia_sp_eui1c_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frankia_sp_eui1c_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frankia_sp_eui1c_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["298654"]),
        None,
        Some("."),
        Some("FraEuI1c_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frankia sp. CN3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "298655.KI912266_gene1";
/// let this_library_node_name2 = "298655.KI912267_gene8014";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frankia_sp_cn3_node_name(this_library_node_name1));
/// assert!(is_valid_string_frankia_sp_cn3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frankia_sp_cn3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frankia_sp_cn3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["298655"]),
        None,
        Some("."),
        Some("KI91226"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus thermophilus HB8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "300852.55771383";
/// let this_library_node_name2 = "300852.55773622";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_thermophilus_hb8_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_thermophilus_hb8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_thermophilus_hb8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_thermophilus_hb8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["300852"]),
        None,
        Some("."),
        Some("5577"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pundamilia nyererei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "303518.XP_005719436.1";
/// let this_library_node_name2 = "303518.XP_005756061.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pundamilia_nyererei_node_name(this_library_node_name1));
/// assert!(is_valid_string_pundamilia_nyererei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pundamilia_nyererei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pundamilia_nyererei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["303518"]),
        None,
        Some("."),
        Some("XP_0057"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanocella paludicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "304371.MCP_0001";
/// let this_library_node_name2 = "304371.MCP_3004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanocella_paludicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanocella_paludicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanocella_paludicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanocella_paludicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["304371"]),
        None,
        Some("."),
        Some("MCP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thauera sp. 27 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "305700.B447_00005";
/// let this_library_node_name2 = "305700.B447_21657";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thauera_sp_27_node_name(this_library_node_name1));
/// assert!(is_valid_string_thauera_sp_27_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thauera_sp_27_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thauera_sp_27_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["305700"]),
        None,
        Some("."),
        Some("B447_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Endozoicomonas elysicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "305900.GV64_00005";
/// let this_library_node_name2 = "305900.GV64_24605";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_endozoicomonas_elysicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_endozoicomonas_elysicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_endozoicomonas_elysicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_endozoicomonas_elysicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["305900"]),
        None,
        Some("."),
        Some("GV64_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter lari nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "306263.Cla_0001";
/// let this_library_node_name2 = "306263.Cla_a042";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_lari_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_lari_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_lari_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_lari_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["306263"]),
        None,
        Some("."),
        Some("Cla_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter upsaliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "306264.CUP0001";
/// let this_library_node_name2 = "306264.CUPA0026";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_upsaliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_upsaliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_upsaliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_upsaliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["306264"]),
        None,
        Some("."),
        Some("CUP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fischerella muscicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "306281.AJLK01000001_gene785";
/// let this_library_node_name2 = "306281.AJLK01000271_gene5709";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fischerella_muscicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_fischerella_muscicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fischerella_muscicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fischerella_muscicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["306281"]),
        None,
        Some("."),
        Some("AJLK01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium jeikeium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "306537.15278131";
/// let this_library_node_name2 = "306537.jk2104";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_jeikeium_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_jeikeium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_jeikeium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_jeikeium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["306537"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium vrystaatense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "307480.IW16_00005";
/// let this_library_node_name2 = "307480.IW16_26840";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_vrystaatense_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_vrystaatense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_vrystaatense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_vrystaatense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["307480"]),
        None,
        Some("."),
        Some("IW16_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coprothermobacter proteolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "309798.COPRO5265_0002";
/// let this_library_node_name2 = "309798.COPRO5265_1598";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coprothermobacter_proteolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_coprothermobacter_proteolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coprothermobacter_proteolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coprothermobacter_proteolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["309798"]),
        None,
        Some("."),
        Some("COPRO5265_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dictyoglomus thermophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "309799.DICTH_0001";
/// let this_library_node_name2 = "309799.DICTH_1991";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dictyoglomus_thermophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_dictyoglomus_thermophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dictyoglomus_thermophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dictyoglomus_thermophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["309799"]),
        None,
        Some("."),
        Some("DICTH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloferax volcanii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "309800.C498_00005";
/// let this_library_node_name2 = "309800.C498_19694";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloferax_volcanii_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloferax_volcanii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloferax_volcanii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloferax_volcanii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["309800"]),
        None,
        Some("."),
        Some("C498_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermomicrobium roseum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "309801.trd_0002";
/// let this_library_node_name2 = "309801.trd_A0937";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermomicrobium_roseum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermomicrobium_roseum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermomicrobium_roseum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermomicrobium_roseum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["309801"]),
        None,
        Some("."),
        Some("trd_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermotoga neapolitana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "309803.CTN_0001";
/// let this_library_node_name2 = "309803.CTN_1937";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermotoga_neapolitana_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermotoga_neapolitana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermotoga_neapolitana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermotoga_neapolitana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["309803"]),
        None,
        Some("."),
        Some("CTN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinibacter ruber nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "309807.SRU_0001";
/// let this_library_node_name2 = "309807.SRU_p0033";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinibacter_ruber_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinibacter_ruber_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinibacter_ruber_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinibacter_ruber_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["309807"]),
        None,
        Some("."),
        Some("SRU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neofusicoccum parvum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "310453.XP_007579329.1";
/// let this_library_node_name2 = "310453.XP_007589694.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neofusicoccum_parvum_node_name(this_library_node_name1));
/// assert!(is_valid_string_neofusicoccum_parvum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neofusicoccum_parvum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neofusicoccum_parvum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["310453"]),
        None,
        Some("."),
        Some("XP_0075"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agrobacterium vitis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "311402.Avi_0001";
/// let this_library_node_name2 = "311402.Avi_9917";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agrobacterium_vitis_node_name(this_library_node_name1));
/// assert!(is_valid_string_agrobacterium_vitis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agrobacterium_vitis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agrobacterium_vitis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["311402"]),
        None,
        Some("."),
        Some("Avi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agrobacterium radiobacter nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "311403.Arad_0001";
/// let this_library_node_name2 = "311403.Arad_9999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agrobacterium_radiobacter_node_name(this_library_node_name1));
/// assert!(is_valid_string_agrobacterium_radiobacter_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agrobacterium_radiobacter_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agrobacterium_radiobacter_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["311403"]),
        None,
        Some("."),
        Some("Arad_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dehalococcoides mccartyi VS nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "311424.DhcVS_1";
/// let this_library_node_name2 = "311424.DhcVS_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dehalococcoides_mccartyi_vs_node_name(this_library_node_name1));
/// assert!(is_valid_string_dehalococcoides_mccartyi_vs_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dehalococcoides_mccartyi_vs_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dehalococcoides_mccartyi_vs_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["311424"]),
        None,
        Some("."),
        Some("DhcVS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polynucleobacter necessarius asymbioticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "312153.Pnuc_0001";
/// let this_library_node_name2 = "312153.Pnuc_2088";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polynucleobacter_necessarius_asymbioticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_polynucleobacter_necessarius_asymbioticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polynucleobacter_necessarius_asymbioticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polynucleobacter_necessarius_asymbioticus_node_name(
    node_name: &str,
) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["312153"]),
        None,
        Some("."),
        Some("Pnuc_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING actinobacterium PHSC20C1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "312284.A20C1_00005";
/// let this_library_node_name2 = "312284.A20C1_13436";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobacterium_phsc20c1_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobacterium_phsc20c1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobacterium_phsc20c1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobacterium_phsc20c1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["312284"]),
        None,
        Some("."),
        Some("A20C1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio fischeri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "312309.VF_0001";
/// let this_library_node_name2 = "312309.VF_B0057";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_fischeri_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_fischeri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_fischeri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_fischeri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["312309"]),
        None,
        Some("."),
        Some("VF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Janibacter sp. HTCC2649 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313589.JNB_00115";
/// let this_library_node_name2 = "313589.JNB_20598";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_janibacter_sp_htcc2649_node_name(this_library_node_name1));
/// assert!(is_valid_string_janibacter_sp_htcc2649_node_name(this_library_node_name2));
/// assert!(!is_valid_string_janibacter_sp_htcc2649_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_janibacter_sp_htcc2649_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313589"]),
        None,
        Some("."),
        Some("JNB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dokdonia sp. MED134 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313590.MED134_00010";
/// let this_library_node_name2 = "313590.MED134_17896";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dokdonia_sp_med134_node_name(this_library_node_name1));
/// assert!(is_valid_string_dokdonia_sp_med134_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dokdonia_sp_med134_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dokdonia_sp_med134_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313590"]),
        None,
        Some("."),
        Some("MED134_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polaribacter irgensii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313594.PI23P_00025";
/// let this_library_node_name2 = "313594.PI23P_12857";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polaribacter_irgensii_node_name(this_library_node_name1));
/// assert!(is_valid_string_polaribacter_irgensii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polaribacter_irgensii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polaribacter_irgensii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313594"]),
        None,
        Some("."),
        Some("PI23P_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychroflexus torquis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313595.P700755_000001";
/// let this_library_node_name2 = "313595.P700755_004059";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychroflexus_torquis_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychroflexus_torquis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychroflexus_torquis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychroflexus_torquis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313595"]),
        None,
        Some("."),
        Some("P700755_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Robiginitalea biformata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313596.RB2501_00005";
/// let this_library_node_name2 = "313596.RB2501_16214";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_robiginitalea_biformata_node_name(this_library_node_name1));
/// assert!(is_valid_string_robiginitalea_biformata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_robiginitalea_biformata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_robiginitalea_biformata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313596"]),
        None,
        Some("."),
        Some("RB2501_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polaribacter sp. MED152 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313598.MED152_00005";
/// let this_library_node_name2 = "313598.MED152_17368";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polaribacter_sp_med152_node_name(this_library_node_name1));
/// assert!(is_valid_string_polaribacter_sp_med152_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polaribacter_sp_med152_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polaribacter_sp_med152_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313598"]),
        None,
        Some("."),
        Some("MED152_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Maribacter sp. HTCC2170 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313603.FB2170_00005";
/// let this_library_node_name2 = "313603.FB2170_17461";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_maribacter_sp_htcc2170_node_name(this_library_node_name1));
/// assert!(is_valid_string_maribacter_sp_htcc2170_node_name(this_library_node_name2));
/// assert!(!is_valid_string_maribacter_sp_htcc2170_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_maribacter_sp_htcc2170_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313603"]),
        None,
        Some("."),
        Some("FB2170_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microscilla marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313606.M23134_00001";
/// let this_library_node_name2 = "313606.M23134_08482";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microscilla_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_microscilla_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microscilla_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microscilla_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313606"]),
        None,
        Some("."),
        Some("M23134_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lyngbya sp. PCC8106 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313612.L8106_00005";
/// let this_library_node_name2 = "313612.L8106_30800";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lyngbya_sp_pcc8106_node_name(this_library_node_name1));
/// assert!(is_valid_string_lyngbya_sp_pcc8106_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lyngbya_sp_pcc8106_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lyngbya_sp_pcc8106_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313612"]),
        None,
        Some("."),
        Some("L8106_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nodularia spumigena nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313624.NSP_10";
/// let this_library_node_name2 = "313624.NSP_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nodularia_spumigena_node_name(this_library_node_name1));
/// assert!(is_valid_string_nodularia_spumigena_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nodularia_spumigena_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nodularia_spumigena_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313624"]),
        None,
        Some("."),
        Some("NSP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. BL107 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313625.BL107_04802";
/// let this_library_node_name2 = "313625.BL107_17400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_bl107_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_bl107_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_bl107_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_bl107_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313625"]),
        None,
        Some("."),
        Some("BL107_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lentisphaera araneosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "313628.LNTAR_00005";
/// let this_library_node_name2 = "313628.LNTAR_25642";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lentisphaera_araneosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_lentisphaera_araneosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lentisphaera_araneosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lentisphaera_araneosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["313628"]),
        None,
        Some("."),
        Some("LNTAR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erythrobacter litoralis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314225.ELI_00010";
/// let this_library_node_name2 = "314225.ELI_15060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erythrobacter_litoralis_node_name(this_library_node_name1));
/// assert!(is_valid_string_erythrobacter_litoralis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erythrobacter_litoralis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erythrobacter_litoralis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314225"]),
        None,
        Some("."),
        Some("ELI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blastopirellula marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314230.DSM3645_01706";
/// let this_library_node_name2 = "314230.DSM3645_30231";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blastopirellula_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_blastopirellula_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blastopirellula_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blastopirellula_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314230"]),
        None,
        Some("."),
        Some("DSM3645_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fulvimarina pelagi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314231.FP2506_00015";
/// let this_library_node_name2 = "314231.FP2506_18886";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fulvimarina_pelagi_node_name(this_library_node_name1));
/// assert!(is_valid_string_fulvimarina_pelagi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fulvimarina_pelagi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fulvimarina_pelagi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314231"]),
        None,
        Some("."),
        Some("FP2506_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Loktanella vestfoldensis SKA53 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314232.SKA53_00005";
/// let this_library_node_name2 = "314232.SKA53_15411";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_loktanella_vestfoldensis_ska53_node_name(this_library_node_name1));
/// assert!(is_valid_string_loktanella_vestfoldensis_ska53_node_name(this_library_node_name2));
/// assert!(!is_valid_string_loktanella_vestfoldensis_ska53_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_loktanella_vestfoldensis_ska53_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314232"]),
        None,
        Some("."),
        Some("SKA53_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanicaulis sp. HTCC2633 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314254.OA2633_00005";
/// let this_library_node_name2 = "314254.OA2633_15234";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanicaulis_sp_htcc2633_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanicaulis_sp_htcc2633_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanicaulis_sp_htcc2633_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanicaulis_sp_htcc2633_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314254"]),
        None,
        Some("."),
        Some("OA2633_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanicola granulosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314256.OG2516_00005";
/// let this_library_node_name2 = "314256.OG2516_19070";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanicola_granulosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanicola_granulosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanicola_granulosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanicola_granulosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314256"]),
        None,
        Some("."),
        Some("OG2516_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parvularcula bermudensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314260.PB2503_00005";
/// let this_library_node_name2 = "314260.PB2503_13669";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parvularcula_bermudensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_parvularcula_bermudensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parvularcula_bermudensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parvularcula_bermudensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314260"]),
        None,
        Some("."),
        Some("PB2503_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseobacter sp. MED193 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314262.MED193_02685";
/// let this_library_node_name2 = "314262.MED193_22791";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseobacter_sp_med193_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseobacter_sp_med193_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseobacter_sp_med193_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseobacter_sp_med193_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314262"]),
        None,
        Some("."),
        Some("MED193_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseovarius sp. 217 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314264.ROS217_00015";
/// let this_library_node_name2 = "314264.ROS217_23945";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseovarius_sp_217_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseovarius_sp_217_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseovarius_sp_217_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseovarius_sp_217_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314264"]),
        None,
        Some("."),
        Some("ROS217_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibaca bermudensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314265.R2601_00005";
/// let this_library_node_name2 = "314265.R2601_27374";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibaca_bermudensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibaca_bermudensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibaca_bermudensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibaca_bermudensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314265"]),
        None,
        Some("."),
        Some("R2601_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. SKA58 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314266.SKA58_00005";
/// let this_library_node_name2 = "314266.SKA58_19315";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_ska58_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_ska58_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_ska58_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_ska58_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314266"]),
        None,
        Some("."),
        Some("SKA58_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodobacteraceae bacterium HTCC2083 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314270.RB2083_1";
/// let this_library_node_name2 = "314270.RB2083_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodobacteraceae_bacterium_htcc2083_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodobacteraceae_bacterium_htcc2083_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodobacteraceae_bacterium_htcc2083_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodobacteraceae_bacterium_htcc2083_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314270"]),
        None,
        Some("."),
        Some("RB2083_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Maritimibacter alkaliphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314271.RB2654_00005";
/// let this_library_node_name2 = "314271.RB2654_23168";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_maritimibacter_alkaliphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_maritimibacter_alkaliphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_maritimibacter_alkaliphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_maritimibacter_alkaliphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314271"]),
        None,
        Some("."),
        Some("RB2654_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alteromonas macleodii Deep nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314275.MADE_000001020675";
/// let this_library_node_name2 = "314275.MADE_1020550";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alteromonas_macleodii_deep_node_name(this_library_node_name1));
/// assert!(is_valid_string_alteromonas_macleodii_deep_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alteromonas_macleodii_deep_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alteromonas_macleodii_deep_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314275"]),
        None,
        Some("."),
        Some("MADE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrococcus mobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314278.NB231_00005";
/// let this_library_node_name2 = "314278.NB231_17615";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrococcus_mobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrococcus_mobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrococcus_mobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrococcus_mobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314278"]),
        None,
        Some("."),
        Some("NB231_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychromonas sp. CNPT3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314282.PCNPT3_00005";
/// let this_library_node_name2 = "314282.PCNPT3_12930";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychromonas_sp_cnpt3_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychromonas_sp_cnpt3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychromonas_sp_cnpt3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychromonas_sp_cnpt3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314282"]),
        None,
        Some("."),
        Some("PCNPT3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Congregibacter litoralis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314285.KT71_000001";
/// let this_library_node_name2 = "314285.KT71_19819";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_congregibacter_litoralis_node_name(this_library_node_name1));
/// assert!(is_valid_string_congregibacter_litoralis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_congregibacter_litoralis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_congregibacter_litoralis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314285"]),
        None,
        Some("."),
        Some("KT71_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium HTCC2207 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314287.GB2207_00005";
/// let this_library_node_name2 = "314287.GB2207_12022";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_htcc2207_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_htcc2207_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_htcc2207_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_htcc2207_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314287"]),
        None,
        Some("."),
        Some("GB2207_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photobacterium angustum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314292.VAS14_00741";
/// let this_library_node_name2 = "314292.VAS14_23144";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photobacterium_angustum_node_name(this_library_node_name1));
/// assert!(is_valid_string_photobacterium_angustum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photobacterium_angustum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photobacterium_angustum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314292"]),
        None,
        Some("."),
        Some("VAS14_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus sakei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314315.LCA_0001";
/// let this_library_node_name2 = "314315.LCA_1886";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_sakei_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_sakei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_sakei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_sakei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314315"]),
        None,
        Some("."),
        Some("LCA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mariprofundus ferrooxydans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314345.SPV1_00005";
/// let this_library_node_name2 = "314345.SPV1_14424";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mariprofundus_ferrooxydans_node_name(this_library_node_name1));
/// assert!(is_valid_string_mariprofundus_ferrooxydans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mariprofundus_ferrooxydans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mariprofundus_ferrooxydans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314345"]),
        None,
        Some("."),
        Some("SPV1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING beta proteobacterium KB13 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314607.KB13_1";
/// let this_library_node_name2 = "314607.KB13_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_beta_proteobacterium_kb13_node_name(this_library_node_name1));
/// assert!(is_valid_string_beta_proteobacterium_kb13_node_name(this_library_node_name2));
/// assert!(!is_valid_string_beta_proteobacterium_kb13_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_beta_proteobacterium_kb13_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314607"]),
        None,
        Some("."),
        Some("KB13_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia hermsii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314723.BH0001";
/// let this_library_node_name2 = "314723.BH_P00217";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_hermsii_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_hermsii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_hermsii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_hermsii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314723"]),
        None,
        Some("."),
        Some("BH"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia turicatae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "314724.BT0001";
/// let this_library_node_name2 = "314724.BT0843A";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_turicatae_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_turicatae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_turicatae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_turicatae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["314724"]),
        None,
        Some("."),
        Some("BT0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia felis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "315456.RF_0001";
/// let this_library_node_name2 = "315456.RF_1400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_felis_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_felis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_felis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_felis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["315456"]),
        None,
        Some("."),
        Some("RF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus weihenstephanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "315730.BcerKBAB4_0001";
/// let this_library_node_name2 = "315730.BcerKBAB4_5764";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_weihenstephanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_weihenstephanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_weihenstephanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_weihenstephanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["315730"]),
        None,
        Some("."),
        Some("BcerKBAB4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus cytotoxicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "315749.Bcer98_0001";
/// let this_library_node_name2 = "315749.Bcer98_4039";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_cytotoxicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_cytotoxicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_cytotoxicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_cytotoxicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["315749"]),
        None,
        Some("."),
        Some("Bcer98_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus pumilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "315750.BPUM_0001";
/// let this_library_node_name2 = "315750.BPUM_3737";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_pumilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_pumilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_pumilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_pumilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["315750"]),
        None,
        Some("."),
        Some("BPUM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodopseudomonas palustris BisA53 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316055.RPE_0001";
/// let this_library_node_name2 = "316055.RPE_4920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodopseudomonas_palustris_bisa53_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodopseudomonas_palustris_bisa53_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodopseudomonas_palustris_bisa53_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodopseudomonas_palustris_bisa53_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316055"]),
        None,
        Some("."),
        Some("RPE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodopseudomonas palustris BisB18 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316056.RPC_0001";
/// let this_library_node_name2 = "316056.RPC_4943";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodopseudomonas_palustris_bisb18_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodopseudomonas_palustris_bisb18_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodopseudomonas_palustris_bisb18_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodopseudomonas_palustris_bisb18_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316056"]),
        None,
        Some("."),
        Some("RPC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodopseudomonas palustris BisB5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316057.RPD_0001";
/// let this_library_node_name2 = "316057.RPD_4421";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodopseudomonas_palustris_bisb5_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodopseudomonas_palustris_bisb5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodopseudomonas_palustris_bisb5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodopseudomonas_palustris_bisb5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316057"]),
        None,
        Some("."),
        Some("RPD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodopseudomonas palustris HaA2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316058.RPB_0001";
/// let this_library_node_name2 = "316058.RPB_4712";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodopseudomonas_palustris_haa2_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodopseudomonas_palustris_haa2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodopseudomonas_palustris_haa2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodopseudomonas_palustris_haa2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316058"]),
        None,
        Some("."),
        Some("RPB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacter daltonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316067.Geob_0001";
/// let this_library_node_name2 = "316067.Geob_3915";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacter_daltonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacter_daltonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacter_daltonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacter_daltonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316067"]),
        None,
        Some("."),
        Some("Geob_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas campestris vesicatoria nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316273.XCV0001";
/// let this_library_node_name2 = "316273.XCVb0022";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_campestris_vesicatoria_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_campestris_vesicatoria_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_campestris_vesicatoria_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_campestris_vesicatoria_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316273"]),
        None,
        Some("."),
        Some("XCV"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Herpetosiphon aurantiacus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316274.Haur_0001";
/// let this_library_node_name2 = "316274.Haur_5303";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_herpetosiphon_aurantiacus_node_name(this_library_node_name1));
/// assert!(is_valid_string_herpetosiphon_aurantiacus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_herpetosiphon_aurantiacus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_herpetosiphon_aurantiacus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316274"]),
        None,
        Some("."),
        Some("Haur_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aliivibrio salmonicida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316275.VSAL_I0001";
/// let this_library_node_name2 = "316275.VSAL_p43_03";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aliivibrio_salmonicida_node_name(this_library_node_name1));
/// assert!(is_valid_string_aliivibrio_salmonicida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aliivibrio_salmonicida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aliivibrio_salmonicida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316275"]),
        None,
        Some("."),
        Some("VSAL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. RCC307 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316278.SynRCC307_0001";
/// let this_library_node_name2 = "316278.SynRCC307_2535";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_rcc307_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_rcc307_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_rcc307_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_rcc307_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316278"]),
        None,
        Some("."),
        Some("SynRCC307_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. CC9902 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316279.Syncc9902_0001";
/// let this_library_node_name2 = "316279.Syncc9902_2321";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_cc9902_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_cc9902_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_cc9902_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_cc9902_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316279"]),
        None,
        Some("."),
        Some("Syncc9902_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia coli K12 W3110 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "316407.1651235";
/// let this_library_node_name2 = "316407.85677142";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_coli_k12_w3110_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_coli_k12_w3110_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_coli_k12_w3110_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_coli_k12_w3110_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["316407"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas axonopodis phaseoli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "317013.NY99_00005";
/// let this_library_node_name2 = "317013.NY99_22500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_axonopodis_phaseoli_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_axonopodis_phaseoli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_axonopodis_phaseoli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_axonopodis_phaseoli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["317013"]),
        None,
        Some("."),
        Some("NY99_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiomicrospira crunogena nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "317025.Tcr_0001";
/// let this_library_node_name2 = "317025.Tcr_2205";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiomicrospira_crunogena_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiomicrospira_crunogena_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiomicrospira_crunogena_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiomicrospira_crunogena_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["317025"]),
        None,
        Some("."),
        Some("Tcr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorothrix hollandica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "317619.ANKN01000001_gene2071";
/// let this_library_node_name2 = "317619.ANKN01000233_gene412";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorothrix_hollandica_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorothrix_hollandica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorothrix_hollandica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorothrix_hollandica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["317619"]),
        None,
        Some("."),
        Some("ANKN01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingopyxis alaskensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "317655.Sala_0001";
/// let this_library_node_name2 = "317655.Sala_3218";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingopyxis_alaskensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingopyxis_alaskensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingopyxis_alaskensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingopyxis_alaskensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["317655"]),
        None,
        Some("."),
        Some("Sala_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nostoc sp. PCC7107 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "317936.Nos7107_0001";
/// let this_library_node_name2 = "317936.Nos7107_5447";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nostoc_sp_pcc7107_node_name(this_library_node_name1));
/// assert!(is_valid_string_nostoc_sp_pcc7107_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nostoc_sp_pcc7107_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nostoc_sp_pcc7107_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["317936"]),
        None,
        Some("."),
        Some("Nos7107_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella denitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "318161.Sden_0001";
/// let this_library_node_name2 = "318161.Sden_3778";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_denitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_denitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_denitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_denitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["318161"]),
        None,
        Some("."),
        Some("Sden_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella frigidimarina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "318167.Sfri_0001";
/// let this_library_node_name2 = "318167.Sfri_4067";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_frigidimarina_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_frigidimarina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_frigidimarina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_frigidimarina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["318167"]),
        None,
        Some("."),
        Some("Sfri_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium rufum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "318424.EU78_00010";
/// let this_library_node_name2 = "318424.EU78_29315";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_rufum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_rufum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_rufum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_rufum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["318424"]),
        None,
        Some("."),
        Some("EU78_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sulfidigenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "318464.IO99_00005";
/// let this_library_node_name2 = "318464.IO99_18840";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sulfidigenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sulfidigenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sulfidigenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sulfidigenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["318464"]),
        None,
        Some("."),
        Some("IO99_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus denitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "318586.Pden_0001";
/// let this_library_node_name2 = "318586.Pden_5134";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_denitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_denitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_denitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_denitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["318586"]),
        None,
        Some("."),
        Some("Pden_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Magnaporthe oryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "318829.MGG_00005T0";
/// let this_library_node_name2 = "318829.MGG_18142T0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_magnaporthe_oryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_magnaporthe_oryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_magnaporthe_oryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_magnaporthe_oryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["318829"]),
        None,
        Some("."),
        Some("MGG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. WSM1743 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "318996.AXAZ01000001_gene4488";
/// let this_library_node_name2 = "318996.AXAZ01000163_gene2241";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_wsm1743_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_wsm1743_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_wsm1743_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_wsm1743_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["318996"]),
        None,
        Some("."),
        Some("AXAZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. WSM1253 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "319003.Bra1253DRAFT_00001";
/// let this_library_node_name2 = "319003.Bra1253DRAFT_08499";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_wsm1253_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_wsm1253_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_wsm1253_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_wsm1253_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["319003"]),
        None,
        Some("."),
        Some("Bra1253DRAFT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella putrefaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "319224.Sputcn32_0001";
/// let this_library_node_name2 = "319224.Sputcn32_4005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_putrefaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_putrefaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_putrefaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_putrefaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["319224"]),
        None,
        Some("."),
        Some("Sputcn32_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorobium luteolum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "319225.Plut_0001";
/// let this_library_node_name2 = "319225.Plut_2133";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorobium_luteolum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorobium_luteolum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorobium_luteolum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorobium_luteolum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["319225"]),
        None,
        Some("."),
        Some("Plut_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nonlabens sediminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "319236.JCM19294_1";
/// let this_library_node_name2 = "319236.JCM19294_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nonlabens_sediminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nonlabens_sediminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nonlabens_sediminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nonlabens_sediminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["319236"]),
        None,
        Some("."),
        Some("JCM19294_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus geothermalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "319795.Dgeo_0001";
/// let this_library_node_name2 = "319795.Dgeo_2875";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_geothermalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_geothermalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_geothermalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_geothermalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["319795"]),
        None,
        Some("."),
        Some("Dgeo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaplasma marginale Florida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "320483.AMF_001";
/// let this_library_node_name2 = "320483.AMF_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaplasma_marginale_florida_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaplasma_marginale_florida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaplasma_marginale_florida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaplasma_marginale_florida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["320483"]),
        None,
        Some("."),
        Some("AMF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. JA33Ab nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "321327.CYA_0001";
/// let this_library_node_name2 = "321327.CYA_2905";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_ja33ab_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_ja33ab_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_ja33ab_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_ja33ab_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["321327"]),
        None,
        Some("."),
        Some("CYA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. JA23Ba nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "321332.CYB_0001";
/// let this_library_node_name2 = "321332.CYB_2942";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_ja23ba_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_ja23ba_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_ja23ba_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_ja23ba_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["321332"]),
        None,
        Some("."),
        Some("CYB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas simiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "321846.PS417_00005";
/// let this_library_node_name2 = "321846.PS417_28555";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_simiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_simiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_simiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_simiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["321846"]),
        None,
        Some("."),
        Some("PS417_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacterium linens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "321955.AAGP01000001_gene3187";
/// let this_library_node_name2 = "321955.AAGP01000076_gene3639";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacterium_linens_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacterium_linens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacterium_linens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacterium_linens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["321955"]),
        None,
        Some("."),
        Some("AAGP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytoplasma wheat blue nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "321961.AVAO01000001_gene401";
/// let this_library_node_name2 = "321961.AVAO01000006_gene571";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytoplasma_wheat_blue_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytoplasma_wheat_blue_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytoplasma_wheat_blue_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytoplasma_wheat_blue_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["321961"]),
        None,
        Some("."),
        Some("AVAO0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytoplasma aster yellows nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "322098.AYWB_001";
/// let this_library_node_name2 = "322098.AYWB_pIV06";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytoplasma_aster_yellows_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytoplasma_aster_yellows_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytoplasma_aster_yellows_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytoplasma_aster_yellows_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["322098"]),
        None,
        Some("."),
        Some("AYWB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus thermophilus LMD9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "322159.STER_0001";
/// let this_library_node_name2 = "322159.STER_B2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_thermophilus_lmd9_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_thermophilus_lmd9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_thermophilus_lmd9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_thermophilus_lmd9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["322159"]),
        None,
        Some("."),
        Some("STER_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Azotobacter vinelandii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "322710.Avin_00010";
/// let this_library_node_name2 = "322710.Avin_52490";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_azotobacter_vinelandii_node_name(this_library_node_name1));
/// assert!(is_valid_string_azotobacter_vinelandii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_azotobacter_vinelandii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_azotobacter_vinelandii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["322710"]),
        None,
        Some("."),
        Some("Avin_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrobacter hamburgensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "323097.Nham_0001";
/// let this_library_node_name2 = "323097.Nham_4539";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrobacter_hamburgensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrobacter_hamburgensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrobacter_hamburgensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrobacter_hamburgensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["323097"]),
        None,
        Some("."),
        Some("Nham_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrobacter winogradskyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "323098.Nwi_0001";
/// let this_library_node_name2 = "323098.Nwi_3143";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrobacter_winogradskyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrobacter_winogradskyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrobacter_winogradskyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrobacter_winogradskyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["323098"]),
        None,
        Some("."),
        Some("Nwi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanospirillum hungatei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "323259.Mhun_0001";
/// let this_library_node_name2 = "323259.Mhun_3238";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanospirillum_hungatei_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanospirillum_hungatei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanospirillum_hungatei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanospirillum_hungatei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["323259"]),
        None,
        Some("."),
        Some("Mhun_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosococcus oceani nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "323261.Noc_0001";
/// let this_library_node_name2 = "323261.Noc_A0043";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosococcus_oceani_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosococcus_oceani_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosococcus_oceani_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosococcus_oceani_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["323261"]),
        None,
        Some("."),
        Some("Noc_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosospira multiformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "323848.Nmul_A0001";
/// let this_library_node_name2 = "323848.Nmul_D2827";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosospira_multiformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosospira_multiformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosospira_multiformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosospira_multiformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["323848"]),
        None,
        Some("."),
        Some("Nmul_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella loihica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "323850.Shew_0001";
/// let this_library_node_name2 = "323850.Shew_3869";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_loihica_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_loihica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_loihica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_loihica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["323850"]),
        None,
        Some("."),
        Some("Shew_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. JDR2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "324057.Pjdr2_0001";
/// let this_library_node_name2 = "324057.Pjdr2_6291";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_jdr2_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_jdr2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_jdr2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_jdr2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["324057"]),
        None,
        Some("."),
        Some("Pjdr2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chloroflexus aurantiacus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "324602.Caur_0001";
/// let this_library_node_name2 = "324602.Caur_3934";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chloroflexus_aurantiacus_node_name(this_library_node_name1));
/// assert!(is_valid_string_chloroflexus_aurantiacus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chloroflexus_aurantiacus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chloroflexus_aurantiacus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["324602"]),
        None,
        Some("."),
        Some("Caur_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus gasseri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "324831.LGAS_0001";
/// let this_library_node_name2 = "324831.LGAS_1898";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_gasseri_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_gasseri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_gasseri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_gasseri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["324831"]),
        None,
        Some("."),
        Some("LGAS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelodictyon phaeoclathratiforme nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "324925.Ppha_0001";
/// let this_library_node_name2 = "324925.Ppha_2924";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelodictyon_phaeoclathratiforme_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelodictyon_phaeoclathratiforme_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelodictyon_phaeoclathratiforme_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelodictyon_phaeoclathratiforme_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["324925"]),
        None,
        Some("."),
        Some("Ppha_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytophthora kernoviae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "325452.fgenesh_scip_prom.46568.1";
/// let this_library_node_name2 = "325452.fgenesh_scip_prom.46568.9999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytophthora_kernoviae_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytophthora_kernoviae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytophthora_kernoviae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytophthora_kernoviae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["325452"]),
        None,
        Some("."),
        Some("fgenesh_scip_prom"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas axonopodis vasculorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "325777.GW15_0200015";
/// let this_library_node_name2 = "325777.GW15_0222560";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_axonopodis_vasculorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_axonopodis_vasculorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_axonopodis_vasculorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_axonopodis_vasculorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["325777"]),
        None,
        Some("."),
        Some("GW15_02"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella amazonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "326297.Sama_0001";
/// let this_library_node_name2 = "326297.Sama_3655";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_amazonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_amazonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_amazonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_amazonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["326297"]),
        None,
        Some("."),
        Some("Sama_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurimonas denitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "326298.Suden_0001";
/// let this_library_node_name2 = "326298.Suden_2104";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurimonas_denitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurimonas_denitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurimonas_denitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurimonas_denitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["326298"]),
        None,
        Some("."),
        Some("Suden_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus amyloliquefaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "326423.RBAM_000010";
/// let this_library_node_name2 = "326423.RBAM_038160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_amyloliquefaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_amyloliquefaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_amyloliquefaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_amyloliquefaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["326423"]),
        None,
        Some("."),
        Some("RBAM_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frankia alni nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "326424.FRAAL0002";
/// let this_library_node_name2 = "326424.FRAAL6889";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frankia_alni_node_name(this_library_node_name1));
/// assert!(is_valid_string_frankia_alni_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frankia_alni_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frankia_alni_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["326424"]),
        None,
        Some("."),
        Some("FRAAL"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus helveticus CNRZ32 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "326425.lhe_0001";
/// let this_library_node_name2 = "326425.lhe_1928";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_helveticus_cnrz32_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_helveticus_cnrz32_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_helveticus_cnrz32_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_helveticus_cnrz32_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["326425"]),
        None,
        Some("."),
        Some("lhe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium breve nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "326426.Bbr_0001";
/// let this_library_node_name2 = "326426.Bbr_1926";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_breve_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_breve_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_breve_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_breve_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["326426"]),
        None,
        Some("."),
        Some("Bbr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chloroflexus aggregans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "326427.Cagg_0001";
/// let this_library_node_name2 = "326427.Cagg_3848";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chloroflexus_aggregans_node_name(this_library_node_name1));
/// assert!(is_valid_string_chloroflexus_aggregans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chloroflexus_aggregans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chloroflexus_aggregans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["326427"]),
        None,
        Some("."),
        Some("Cagg_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas haloplanktis TAC125 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "326442.PSHAa0001";
/// let this_library_node_name2 = "326442.PSHAb0561";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_haloplanktis_tac125_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_haloplanktis_tac125_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_haloplanktis_tac125_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_haloplanktis_tac125_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["326442"]),
        None,
        Some("."),
        Some("PSHA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudozyma hubeiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "327079.R9NVI6";
/// let this_library_node_name2 = "327079.R9PP88";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudozyma_hubeiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudozyma_hubeiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudozyma_hubeiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudozyma_hubeiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["327079"]),
        None,
        Some("."),
        Some("R9"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium crudilactis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "327277.JHAL01000001_gene1381";
/// let this_library_node_name2 = "327277.JHAL01000006_gene33";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_crudilactis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_crudilactis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_crudilactis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_crudilactis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["327277"]),
        None,
        Some("."),
        Some("JHAL0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acaryochloris marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "329726.AM1_0003";
/// let this_library_node_name2 = "329726.AM1_G0173";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acaryochloris_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_acaryochloris_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acaryochloris_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acaryochloris_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["329726"]),
        None,
        Some("."),
        Some("AM1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolatopsis jejuensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "330084.JNYZ01000001_gene3014";
/// let this_library_node_name2 = "330084.JNYZ01000136_gene3901";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolatopsis_jejuensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolatopsis_jejuensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolatopsis_jejuensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolatopsis_jejuensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["330084"]),
        None,
        Some("."),
        Some("JNYZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrospira defluvii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "330214.NIDE0001";
/// let this_library_node_name2 = "330214.NIDE4400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrospira_defluvii_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrospira_defluvii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrospira_defluvii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrospira_defluvii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["330214"]),
        None,
        Some("."),
        Some("NIDE"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfolobus acidocaldarius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "330779.Saci_0001";
/// let this_library_node_name2 = "330779.Saci_2375";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfolobus_acidocaldarius_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfolobus_acidocaldarius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfolobus_acidocaldarius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfolobus_acidocaldarius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["330779"]),
        None,
        Some("."),
        Some("Saci_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blattabacterium sp. Bge nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "331104.BLBBGE_001";
/// let this_library_node_name2 = "331104.BLBBGE_p004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blattabacterium_sp_bge_node_name(this_library_node_name1));
/// assert!(is_valid_string_blattabacterium_sp_bge_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blattabacterium_sp_bge_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blattabacterium_sp_bge_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["331104"]),
        None,
        Some("."),
        Some("BLBBGE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Simkania negevensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "331113.SNE_A00010";
/// let this_library_node_name2 = "331113.SNE_B25190";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_simkania_negevensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_simkania_negevensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_simkania_negevensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_simkania_negevensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["331113"]),
        None,
        Some("."),
        Some("SNE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydophila pecorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "331635.G5S_0001";
/// let this_library_node_name2 = "331635.G5S_1114";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydophila_pecorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydophila_pecorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydophila_pecorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydophila_pecorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["331635"]),
        None,
        Some("."),
        Some("G5S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydia psittaci 6BC nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "331636.G5O_0008";
/// let this_library_node_name2 = "331636.G5O_1064";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydia_psittaci_6bc_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydia_psittaci_6bc_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydia_psittaci_6bc_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydia_psittaci_6bc_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["331636"]),
        None,
        Some("."),
        Some("G5O_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorobium phaeobacteroides BS1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "331678.Cphamn1_0001";
/// let this_library_node_name2 = "331678.Cphamn1_2564";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorobium_phaeobacteroides_bs1_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorobium_phaeobacteroides_bs1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorobium_phaeobacteroides_bs1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorobium_phaeobacteroides_bs1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["331678"]),
        None,
        Some("."),
        Some("Cphamn1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING alpha proteobacterium BAL199 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "331869.BAL199_00005";
/// let this_library_node_name2 = "331869.BAL199_30744";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alpha_proteobacterium_bal199_node_name(this_library_node_name1));
/// assert!(is_valid_string_alpha_proteobacterium_bal199_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alpha_proteobacterium_bal199_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alpha_proteobacterium_bal199_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["331869"]),
        None,
        Some("."),
        Some("BAL199_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium drakei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "332101.JIBU02000001_gene4228";
/// let this_library_node_name2 = "332101.JIBU02000120_gene4198";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_drakei_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_drakei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_drakei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_drakei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["332101"]),
        None,
        Some("."),
        Some("JIBU02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus okhensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "333138.LQ50_00005";
/// let this_library_node_name2 = "333138.LQ50_25815";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_okhensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_okhensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_okhensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_okhensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["333138"]),
        None,
        Some("."),
        Some("LQ50_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus fermentum IFO3956 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "334390.LAF_0001";
/// let this_library_node_name2 = "334390.LAF_1843";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_fermentum_ifo3956_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_fermentum_ifo3956_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_fermentum_ifo3956_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_fermentum_ifo3956_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["334390"]),
        None,
        Some("."),
        Some("LAF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Finegoldia magna ATCC29328 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "334413.FMG_0001";
/// let this_library_node_name2 = "334413.FMG_P0182";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_finegoldia_magna_atcc29328_node_name(this_library_node_name1));
/// assert!(is_valid_string_finegoldia_magna_atcc29328_node_name(this_library_node_name2));
/// assert!(!is_valid_string_finegoldia_magna_atcc29328_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_finegoldia_magna_atcc29328_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["334413"]),
        None,
        Some("."),
        Some("FMG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia tamurae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "334545.CCMG01000001_gene1";
/// let this_library_node_name2 = "334545.CCMG01000027_gene1629";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_tamurae_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_tamurae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_tamurae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_tamurae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["334545"]),
        None,
        Some("."),
        Some("CCMG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosomonas eutropha nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "335283.Neut_0001";
/// let this_library_node_name2 = "335283.Neut_2642";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosomonas_eutropha_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosomonas_eutropha_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosomonas_eutropha_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosomonas_eutropha_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["335283"]),
        None,
        Some("."),
        Some("Neut_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter cryohalolentis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "335284.Pcryo_0001";
/// let this_library_node_name2 = "335284.Pcryo_2518";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_cryohalolentis_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_cryohalolentis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_cryohalolentis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_cryohalolentis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["335284"]),
        None,
        Some("."),
        Some("Pcryo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Syntrophomonas wolfei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "335541.Swol_0001";
/// let this_library_node_name2 = "335541.Swol_2577";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_syntrophomonas_wolfei_node_name(this_library_node_name1));
/// assert!(is_valid_string_syntrophomonas_wolfei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_syntrophomonas_wolfei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_syntrophomonas_wolfei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["335541"]),
        None,
        Some("."),
        Some("Swol_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Syntrophobacter fumaroxidans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "335543.Sfum_0001";
/// let this_library_node_name2 = "335543.Sfum_4103";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_syntrophobacter_fumaroxidans_node_name(this_library_node_name1));
/// assert!(is_valid_string_syntrophobacter_fumaroxidans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_syntrophobacter_fumaroxidans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_syntrophobacter_fumaroxidans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["335543"]),
        None,
        Some("."),
        Some("Sfum_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. S23321 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "335659.S23_00010";
/// let this_library_node_name2 = "335659.S23_69510";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_s23321_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_s23321_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_s23321_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_s23321_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["335659"]),
        None,
        Some("."),
        Some("S23_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibacter ubique HTCC1062 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "335992.SAR11_0001";
/// let this_library_node_name2 = "335992.SAR11_1732";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibacter_ubique_htcc1062_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibacter_ubique_htcc1062_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibacter_ubique_htcc1062_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibacter_ubique_htcc1062_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["335992"]),
        None,
        Some("."),
        Some("SAR11_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia bellii RML369C nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "336407.RBE_0001";
/// let this_library_node_name2 = "336407.RBE_1429";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_bellii_rml369c_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_bellii_rml369c_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_bellii_rml369c_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_bellii_rml369c_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["336407"]),
        None,
        Some("."),
        Some("RBE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyronema omphalodes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "337075.U4KTQ2";
/// let this_library_node_name2 = "337075.W1I9Z0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyronema_omphalodes_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyronema_omphalodes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyronema_omphalodes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyronema_omphalodes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["337075"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia sp. KTR9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "337191.KTR9_0001";
/// let this_library_node_name2 = "337191.KTR9_5254";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_sp_ktr9_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_sp_ktr9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_sp_ktr9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_sp_ktr9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["337191"]),
        None,
        Some("."),
        Some("KTR9_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelobacter carbinolicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "338963.Pcar_0001";
/// let this_library_node_name2 = "338963.Pcar_3492";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelobacter_carbinolicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelobacter_carbinolicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelobacter_carbinolicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelobacter_carbinolicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["338963"]),
        None,
        Some("."),
        Some("Pcar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelobacter propionicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "338966.Ppro_0001";
/// let this_library_node_name2 = "338966.Ppro_3825";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelobacter_propionicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelobacter_propionicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelobacter_propionicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelobacter_propionicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["338966"]),
        None,
        Some("."),
        Some("Ppro_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodoferax ferrireducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "338969.Rfer_0001";
/// let this_library_node_name2 = "338969.Rfer_4495";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodoferax_ferrireducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodoferax_ferrireducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodoferax_ferrireducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodoferax_ferrireducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["338969"]),
        None,
        Some("."),
        Some("Rfer_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia ambifaria nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "339670.Bamb_0001";
/// let this_library_node_name2 = "339670.Bamb_6635";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_ambifaria_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_ambifaria_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_ambifaria_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_ambifaria_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["339670"]),
        None,
        Some("."),
        Some("Bamb_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobacillus succinogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "339671.Asuc_0001";
/// let this_library_node_name2 = "339671.Asuc_2117";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobacillus_succinogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobacillus_succinogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobacillus_succinogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobacillus_succinogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["339671"]),
        None,
        Some("."),
        Some("Asuc_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanosphaera stadtmanae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "339860.Msp_0001";
/// let this_library_node_name2 = "339860.Msp_1588";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanosphaera_stadtmanae_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanosphaera_stadtmanae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanosphaera_stadtmanae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanosphaera_stadtmanae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["339860"]),
        None,
        Some("."),
        Some("Msp_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoanaerobacter pseudethanolicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "340099.Teth39_0001";
/// let this_library_node_name2 = "340099.Teth39_2295";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoanaerobacter_pseudethanolicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoanaerobacter_pseudethanolicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoanaerobacter_pseudethanolicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoanaerobacter_pseudethanolicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["340099"]),
        None,
        Some("."),
        Some("Teth39_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spathaspora passalidarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "340170.XP_007372028.1";
/// let this_library_node_name2 = "340170.XP_007378010.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spathaspora_passalidarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_spathaspora_passalidarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spathaspora_passalidarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spathaspora_passalidarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["340170"]),
        None,
        Some("."),
        Some("XP_00737"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorobium chlorochromatii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "340177.Cag_0001";
/// let this_library_node_name2 = "340177.Cag_2033";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorobium_chlorochromatii_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorobium_chlorochromatii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorobium_chlorochromatii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorobium_chlorochromatii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["340177"]),
        None,
        Some("."),
        Some("Cag_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia oklahomensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "342113.DM82_1";
/// let this_library_node_name2 = "342113.DM82_998";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_oklahomensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_oklahomensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_oklahomensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_oklahomensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["342113"]),
        None,
        Some("."),
        Some("DM82_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus saprophyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "342451.SSP0001";
/// let this_library_node_name2 = "342451.SSPP145";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_saprophyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_saprophyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_saprophyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_saprophyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["342451"]),
        None,
        Some("."),
        Some("SSP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas atlantica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "342610.Patl_0001";
/// let this_library_node_name2 = "342610.Patl_4315";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_atlantica_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_atlantica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_atlantica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_atlantica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["342610"]),
        None,
        Some("."),
        Some("Patl_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrococcus sp. NA2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "342949.PNA2_0001";
/// let this_library_node_name2 = "342949.PNA2_1984";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrococcus_sp_na2_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrococcus_sp_na2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrococcus_sp_na2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrococcus_sp_na2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["342949"]),
        None,
        Some("."),
        Some("PNA2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sodalis glossinidius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "343509.SG0001";
/// let this_library_node_name2 = "343509.SGP2_0023";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sodalis_glossinidius_node_name(this_library_node_name1));
/// assert!(is_valid_string_sodalis_glossinidius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sodalis_glossinidius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sodalis_glossinidius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["343509"]),
        None,
        Some("."),
        Some("SG"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Planctomyces maris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "344747.PM8797T_00005";
/// let this_library_node_name2 = "344747.PM8797T_32505";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_planctomyces_maris_node_name(this_library_node_name1));
/// assert!(is_valid_string_planctomyces_maris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_planctomyces_maris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_planctomyces_maris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["344747"]),
        None,
        Some("."),
        Some("PM8797T_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio cholerae O395 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "345073.VC395_0002";
/// let this_library_node_name2 = "345073.VC395_A1135";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_cholerae_o395_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_cholerae_o395_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_cholerae_o395_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_cholerae_o395_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["345073"]),
        None,
        Some("."),
        Some("VC395_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus coagulans 36D1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "345219.Bcoa_0001";
/// let this_library_node_name2 = "345219.Bcoa_3344";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_coagulans_36d1_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_coagulans_36d1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_coagulans_36d1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_coagulans_36d1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["345219"]),
        None,
        Some("."),
        Some("Bcoa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kutzneria sp. 744 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "345341.KUTG_00001";
/// let this_library_node_name2 = "345341.KUTG_10200";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kutzneria_sp_744_node_name(this_library_node_name1));
/// assert!(is_valid_string_kutzneria_sp_744_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kutzneria_sp_744_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kutzneria_sp_744_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["345341"]),
        None,
        Some("."),
        Some("KUTG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma hominis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "347256.MHO_0010";
/// let this_library_node_name2 = "347256.MHO_5380";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_hominis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_hominis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_hominis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_hominis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["347256"]),
        None,
        Some("."),
        Some("MHO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium etli CFN42 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "347834.RHE_CH00001";
/// let this_library_node_name2 = "347834.RHE_PC00234";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_etli_cfn42_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_etli_cfn42_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_etli_cfn42_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_etli_cfn42_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["347834"]),
        None,
        Some("."),
        Some("RHE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natronomonas pharaonis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "348780.NP1716A";
/// let this_library_node_name2 = "348780.NP_5378A";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natronomonas_pharaonis_node_name(this_library_node_name1));
/// assert!(is_valid_string_natronomonas_pharaonis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natronomonas_pharaonis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natronomonas_pharaonis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["348780"]),
        None,
        Some("."),
        Some("NP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. LPU83 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "348824.LPU83_0001";
/// let this_library_node_name2 = "348824.LPU83_pLPU83a_0161";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_lpu83_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_lpu83_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_lpu83_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_lpu83_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["348824"]),
        None,
        Some("."),
        Some("LPU83_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodobacter sphaeroides ATCC17025 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349102.Rsph17025_0001";
/// let this_library_node_name2 = "349102.Rsph17025_4357";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodobacter_sphaeroides_atcc17025_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodobacter_sphaeroides_atcc17025_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodobacter_sphaeroides_atcc17025_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodobacter_sphaeroides_atcc17025_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349102"]),
        None,
        Some("."),
        Some("Rsph17025_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter sp. PRwf1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349106.PsycPRwf_0001";
/// let this_library_node_name2 = "349106.PsycPRwf_2405";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_sp_prwf1_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_sp_prwf1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_sp_prwf1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_sp_prwf1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349106"]),
        None,
        Some("."),
        Some("PsycPRwf_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus reuteri 10023 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349123.Lreu23DRAFT_3001";
/// let this_library_node_name2 = "349123.Lreu23DRAFT_5198";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_reuteri_10023_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_reuteri_10023_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_reuteri_10023_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_reuteri_10023_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349123"]),
        None,
        Some("."),
        Some("Lreu23DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halorhodospira halophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349124.Hhal_0001";
/// let this_library_node_name2 = "349124.Hhal_2439";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halorhodospira_halophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_halorhodospira_halophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halorhodospira_halophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halorhodospira_halophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349124"]),
        None,
        Some("."),
        Some("Hhal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum reducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349161.Dred_0001";
/// let this_library_node_name2 = "349161.Dred_3329";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_reducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_reducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_reducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_reducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349161"]),
        None,
        Some("."),
        Some("Dred_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidiphilium cryptum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349163.Acry_0001";
/// let this_library_node_name2 = "349163.Acry_3585";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidiphilium_cryptum_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidiphilium_cryptum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidiphilium_cryptum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidiphilium_cryptum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349163"]),
        None,
        Some("."),
        Some("Acry_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leuconostoc citreum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349519.LCK_00001";
/// let this_library_node_name2 = "349519.LCK_p400013";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leuconostoc_citreum_node_name(this_library_node_name1));
/// assert!(is_valid_string_leuconostoc_citreum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leuconostoc_citreum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leuconostoc_citreum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349519"]),
        None,
        Some("."),
        Some("LCK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus polymyxa E681 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349520.PPE_00001";
/// let this_library_node_name2 = "349520.PPE_04953";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_polymyxa_e681_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_polymyxa_e681_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_polymyxa_e681_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_polymyxa_e681_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349520"]),
        None,
        Some("."),
        Some("PPE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hahella chejuensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349521.HCH_00001";
/// let this_library_node_name2 = "349521.HCH_10038";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hahella_chejuensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_hahella_chejuensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hahella_chejuensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hahella_chejuensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349521"]),
        None,
        Some("."),
        Some("HCH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Akkermansia muciniphila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349741.Amuc_0001";
/// let this_library_node_name2 = "349741.Amuc_2178";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_akkermansia_muciniphila_node_name(this_library_node_name1));
/// assert!(is_valid_string_akkermansia_muciniphila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_akkermansia_muciniphila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_akkermansia_muciniphila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349741"]),
        None,
        Some("."),
        Some("Amuc_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yersinia intermedia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349965.yinte0001_10";
/// let this_library_node_name2 = "349965.yinte0001_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yersinia_intermedia_node_name(this_library_node_name1));
/// assert!(is_valid_string_yersinia_intermedia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yersinia_intermedia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yersinia_intermedia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349965"]),
        None,
        Some("."),
        Some("yinte0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yersinia frederiksenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "349966.DJ58_1";
/// let this_library_node_name2 = "349966.DJ58_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yersinia_frederiksenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_yersinia_frederiksenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yersinia_frederiksenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yersinia_frederiksenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["349966"]),
        None,
        Some("."),
        Some("DJ58_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium gilvum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "350054.Mflv_0001";
/// let this_library_node_name2 = "350054.Mflv_5598";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_gilvum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_gilvum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_gilvum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_gilvum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["350054"]),
        None,
        Some("."),
        Some("Mflv_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium vanbaalenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "350058.Mvan_0001";
/// let this_library_node_name2 = "350058.Mvan_6078";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_vanbaalenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_vanbaalenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_vanbaalenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_vanbaalenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["350058"]),
        None,
        Some("."),
        Some("Mvan_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alkaliphilus oremlandii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "350688.Clos_0001";
/// let this_library_node_name2 = "350688.Clos_2877";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alkaliphilus_oremlandii_node_name(this_library_node_name1));
/// assert!(is_valid_string_alkaliphilus_oremlandii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alkaliphilus_oremlandii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alkaliphilus_oremlandii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["350688"]),
        None,
        Some("."),
        Some("Clos_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseobacter sp. AzwK3b nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "351016.RAZWK3B_00005";
/// let this_library_node_name2 = "351016.RAZWK3B_20801";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseobacter_sp_azwk3b_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseobacter_sp_azwk3b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseobacter_sp_azwk3b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseobacter_sp_azwk3b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["351016"]),
        None,
        Some("."),
        Some("RAZWK3B_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanocella arvoryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "351160.LM1";
/// let this_library_node_name2 = "351160.RRC99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanocella_arvoryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanocella_arvoryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanocella_arvoryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanocella_arvoryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["351160"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter hydrocarbonoclasticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "351348.Maqu_0001";
/// let this_library_node_name2 = "351348.Maqu_4328";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_hydrocarbonoclasticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_hydrocarbonoclasticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_hydrocarbonoclasticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_hydrocarbonoclasticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["351348"]),
        None,
        Some("."),
        Some("Maqu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidothermus cellulolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "351607.Acel_0001";
/// let this_library_node_name2 = "351607.Acel_2161";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidothermus_cellulolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidothermus_cellulolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidothermus_cellulolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidothermus_cellulolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["351607"]),
        None,
        Some("."),
        Some("Acel_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldicellulosiruptor saccharolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "351627.Csac_0001";
/// let this_library_node_name2 = "351627.Csac_3037";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldicellulosiruptor_saccharolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldicellulosiruptor_saccharolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldicellulosiruptor_saccharolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldicellulosiruptor_saccharolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["351627"]),
        None,
        Some("."),
        Some("Csac_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas putida F1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "351746.Pput_0001";
/// let this_library_node_name2 = "351746.Pput_5311";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_putida_f1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_putida_f1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_putida_f1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_putida_f1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["351746"]),
        None,
        Some("."),
        Some("Pput_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyramidobacter piscolens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "352165.HMPREF7215_0003";
/// let this_library_node_name2 = "352165.HMPREF7215_2835";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyramidobacter_piscolens_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyramidobacter_piscolens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyramidobacter_piscolens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyramidobacter_piscolens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["352165"]),
        None,
        Some("."),
        Some("HMPREF7215_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus delbrueckii 2038 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "353496.LBU_0001";
/// let this_library_node_name2 = "353496.LBU_1792";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_delbrueckii_2038_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_delbrueckii_2038_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_delbrueckii_2038_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_delbrueckii_2038_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["353496"]),
        None,
        Some("."),
        Some("LBU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter jejuni 81176 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "354242.CJJ81176_0001";
/// let this_library_node_name2 = "354242.CJJ81176_pVir0053";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_jejuni_81176_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_jejuni_81176_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_jejuni_81176_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_jejuni_81176_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["354242"]),
        None,
        Some("."),
        Some("CJJ81176_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium tsurumiense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "356829.BITS_0002";
/// let this_library_node_name2 = "356829.BITS_5030";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_tsurumiense_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_tsurumiense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_tsurumiense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_tsurumiense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["356829"]),
        None,
        Some("."),
        Some("BITS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Micromonospora chokoriensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "356851.JOAN01000001_gene3220";
/// let this_library_node_name2 = "356851.JOAN01000060_gene5050";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_micromonospora_chokoriensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_micromonospora_chokoriensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_micromonospora_chokoriensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_micromonospora_chokoriensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["356851"]),
        None,
        Some("."),
        Some("JOAN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Orientia tsutsugamushi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "357244.146739866";
/// let this_library_node_name2 = "357244.OTBS_2179";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_orientia_tsutsugamushi_node_name(this_library_node_name1));
/// assert!(is_valid_string_orientia_tsutsugamushi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_orientia_tsutsugamushi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_orientia_tsutsugamushi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["357244"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides dorei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "357276.EL88_00005";
/// let this_library_node_name2 = "357276.EL88_24875";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_dorei_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_dorei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_dorei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_dorei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["357276"]),
        None,
        Some("."),
        Some("EL88_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychromonas ingrahamii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "357804.Ping_0001";
/// let this_library_node_name2 = "357804.Ping_3742";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychromonas_ingrahamii_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychromonas_ingrahamii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychromonas_ingrahamii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychromonas_ingrahamii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["357804"]),
        None,
        Some("."),
        Some("Ping_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseiflexus sp. RS1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "357808.RoseRS_0001";
/// let this_library_node_name2 = "357808.RoseRS_4629";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseiflexus_sp_rs1_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseiflexus_sp_rs1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseiflexus_sp_rs1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseiflexus_sp_rs1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["357808"]),
        None,
        Some("."),
        Some("RoseRS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnoclostridium phytofermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "357809.Cphy_0001";
/// let this_library_node_name2 = "357809.Cphy_3946";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnoclostridium_phytofermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnoclostridium_phytofermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnoclostridium_phytofermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnoclostridium_phytofermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["357809"]),
        None,
        Some("."),
        Some("Cphy_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidovorax sp. KKS102 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "358220.C380_00005";
/// let this_library_node_name2 = "358220.C380_23910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidovorax_sp_kks102_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidovorax_sp_kks102_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidovorax_sp_kks102_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidovorax_sp_kks102_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["358220"]),
        None,
        Some("."),
        Some("C380_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halobiforma lacisalsi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "358396.C445_00005";
/// let this_library_node_name2 = "358396.C445_21136";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halobiforma_lacisalsi_node_name(this_library_node_name1));
/// assert!(is_valid_string_halobiforma_lacisalsi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halobiforma_lacisalsi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halobiforma_lacisalsi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["358396"]),
        None,
        Some("."),
        Some("C445_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacillus brevis NBRC100599 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "358681.BBR47_00010";
/// let this_library_node_name2 = "358681.BBR47_59490";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacillus_brevis_nbrc100599_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacillus_brevis_nbrc100599_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacillus_brevis_nbrc100599_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacillus_brevis_nbrc100599_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["358681"]),
        None,
        Some("."),
        Some("BBR47_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces olindensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "358823.DF19_00010";
/// let this_library_node_name2 = "358823.DF19_42910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_olindensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_olindensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_olindensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_olindensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["358823"]),
        None,
        Some("."),
        Some("DF19_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas oryzae PXO99A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "360094.PXO_00002";
/// let this_library_node_name2 = "360094.PXO_06277";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_oryzae_pxo99a_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_oryzae_pxo99a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_oryzae_pxo99a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_oryzae_pxo99a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["360094"]),
        None,
        Some("."),
        Some("PXO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella bacilliformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "360095.BARBAKC583_0001";
/// let this_library_node_name2 = "360095.BARBAKC583_1375";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_bacilliformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_bacilliformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_bacilliformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_bacilliformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["360095"]),
        None,
        Some("."),
        Some("BARBAKC583_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter concisus 13826 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "360104.CCC13826_0001";
/// let this_library_node_name2 = "360104.CCC13826_2335";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_concisus_13826_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_concisus_13826_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_concisus_13826_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_concisus_13826_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["360104"]),
        None,
        Some("."),
        Some("CCC13826_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter fetus 8240 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "360106.CFF8240_0001";
/// let this_library_node_name2 = "360106.CFF8240_1822";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_fetus_8240_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_fetus_8240_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_fetus_8240_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_fetus_8240_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["360106"]),
        None,
        Some("."),
        Some("CFF8240_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter hominis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "360107.CHAB381_0001";
/// let this_library_node_name2 = "360107.CHAB381_A0005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_hominis_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_hominis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_hominis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_hominis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["360107"]),
        None,
        Some("."),
        Some("CHAB381_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bordetella avium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "360910.BAV0001";
/// let this_library_node_name2 = "360910.BAV3426";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bordetella_avium_node_name(this_library_node_name1));
/// assert!(is_valid_string_bordetella_avium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bordetella_avium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bordetella_avium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["360910"]),
        None,
        Some("."),
        Some("BAV"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Exiguobacterium sp. AT1b nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "360911.EAT1b_0001";
/// let this_library_node_name2 = "360911.EAT1b_3043";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_exiguobacterium_sp_at1b_node_name(this_library_node_name1));
/// assert!(is_valid_string_exiguobacterium_sp_at1b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_exiguobacterium_sp_at1b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_exiguobacterium_sp_at1b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["360911"]),
        None,
        Some("."),
        Some("EAT1b_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium ulcerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "362242.MUL_0001";
/// let this_library_node_name2 = "362242.MUL_5127";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_ulcerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_ulcerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_ulcerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_ulcerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["362242"]),
        None,
        Some("."),
        Some("MUL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium reichenbachii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "362418.IW19_00010";
/// let this_library_node_name2 = "362418.IW19_24950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_reichenbachii_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_reichenbachii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_reichenbachii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_reichenbachii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["362418"]),
        None,
        Some("."),
        Some("IW19_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia coli 536 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "362663.ECP_0001";
/// let this_library_node_name2 = "362663.ECP_4787";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_coli_536_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_coli_536_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_coli_536_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_coli_536_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["362663"]),
        None,
        Some("."),
        Some("ECP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloquadratum walsbyi DSM16790 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "362976.HQ_1001A";
/// let this_library_node_name2 = "362976.HQ_4039A";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloquadratum_walsbyi_dsm16790_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloquadratum_walsbyi_dsm16790_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloquadratum_walsbyi_dsm16790_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloquadratum_walsbyi_dsm16790_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["362976"]),
        None,
        Some("."),
        Some("HQ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lawsonia intracellularis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "363253.LI0001";
/// let this_library_node_name2 = "363253.LIB024";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lawsonia_intracellularis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lawsonia_intracellularis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lawsonia_intracellularis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lawsonia_intracellularis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["363253"]),
        None,
        Some("."),
        Some("LI"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Endocarpon pusillum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "364733.XP_007785417.1";
/// let this_library_node_name2 = "364733.XP_007806340.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_endocarpon_pusillum_node_name(this_library_node_name1));
/// assert!(is_valid_string_endocarpon_pusillum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_endocarpon_pusillum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_endocarpon_pusillum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["364733"]),
        None,
        Some("."),
        Some("XP_007"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polaromonas naphthalenivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "365044.Pnap_0002";
/// let this_library_node_name2 = "365044.Pnap_4610";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polaromonas_naphthalenivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_polaromonas_naphthalenivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polaromonas_naphthalenivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polaromonas_naphthalenivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["365044"]),
        None,
        Some("."),
        Some("Pnap_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ramlibacter tataouinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "365046.Rta_00010";
/// let this_library_node_name2 = "365046.Rta_38235";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ramlibacter_tataouinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ramlibacter_tataouinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ramlibacter_tataouinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ramlibacter_tataouinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["365046"]),
        None,
        Some("."),
        Some("Rta_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frankia sp. BCU110501 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "365528.KB891102_gene4201";
/// let this_library_node_name2 = "365528.KB891295_gene447";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frankia_sp_bcu110501_node_name(this_library_node_name1));
/// assert!(is_valid_string_frankia_sp_bcu110501_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frankia_sp_bcu110501_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frankia_sp_bcu110501_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["365528"]),
        None,
        Some("."),
        Some("KB891"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis B6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "365659.smi_0001";
/// let this_library_node_name2 = "365659.smi_2089";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_b6_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_b6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_b6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_b6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["365659"]),
        None,
        Some("."),
        Some("smi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sinorhizobium medicae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "366394.Smed_0001";
/// let this_library_node_name2 = "366394.Smed_6328";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sinorhizobium_medicae_node_name(this_library_node_name1));
/// assert!(is_valid_string_sinorhizobium_medicae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sinorhizobium_medicae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sinorhizobium_medicae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["366394"]),
        None,
        Some("."),
        Some("Smed_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caulobacter sp. K31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "366602.Caul_0001";
/// let this_library_node_name2 = "366602.Caul_5462";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caulobacter_sp_k31_node_name(this_library_node_name1));
/// assert!(is_valid_string_caulobacter_sp_k31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caulobacter_sp_k31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caulobacter_sp_k31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["366602"]),
        None,
        Some("."),
        Some("Caul_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas fuscans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "366649.XFF4834R_chr00010";
/// let this_library_node_name2 = "366649.XFF4834R_chr42980";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_fuscans_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_fuscans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_fuscans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_fuscans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["366649"]),
        None,
        Some("."),
        Some("XFF4834R_chr"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phycicoccus jejuensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "367299.JOEE01000001_gene1459";
/// let this_library_node_name2 = "367299.JOEE01000097_gene1453";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phycicoccus_jejuensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_phycicoccus_jejuensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phycicoccus_jejuensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phycicoccus_jejuensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["367299"]),
        None,
        Some("."),
        Some("JOEE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodobacterales bacterium HTCC2255 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "367336.OM2255_00062";
/// let this_library_node_name2 = "367336.OM2255_13733";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodobacterales_bacterium_htcc2255_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodobacterales_bacterium_htcc2255_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodobacterales_bacterium_htcc2255_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodobacterales_bacterium_htcc2255_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["367336"]),
        None,
        Some("."),
        Some("OM2255_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arcobacter butzleri RM4018 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "367737.Abu_0001";
/// let this_library_node_name2 = "367737.Abu_2335";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arcobacter_butzleri_rm4018_node_name(this_library_node_name1));
/// assert!(is_valid_string_arcobacter_butzleri_rm4018_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arcobacter_butzleri_rm4018_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arcobacter_butzleri_rm4018_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["367737"]),
        None,
        Some("."),
        Some("Abu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanoculleus marisnigri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "368407.Memar_0001";
/// let this_library_node_name2 = "368407.Memar_2503";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanoculleus_marisnigri_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanoculleus_marisnigri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanoculleus_marisnigri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanoculleus_marisnigri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["368407"]),
        None,
        Some("."),
        Some("Memar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermofilum pendens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "368408.Tpen_0001";
/// let this_library_node_name2 = "368408.Tpen_1891";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermofilum_pendens_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermofilum_pendens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermofilum_pendens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermofilum_pendens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["368408"]),
        None,
        Some("."),
        Some("Tpen_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinispora tropica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "369723.Strop_0001";
/// let this_library_node_name2 = "369723.Strop_4593";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinispora_tropica_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinispora_tropica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinispora_tropica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinispora_tropica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["369723"]),
        None,
        Some("."),
        Some("Strop_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelotomaculum thermopropionicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "370438.PTH_0001";
/// let this_library_node_name2 = "370438.PTH_2920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelotomaculum_thermopropionicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelotomaculum_thermopropionicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelotomaculum_thermopropionicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelotomaculum_thermopropionicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["370438"]),
        None,
        Some("."),
        Some("PTH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erwinia typographi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "371042.NG99_00005";
/// let this_library_node_name2 = "371042.NG99_27360";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erwinia_typographi_node_name(this_library_node_name1));
/// assert!(is_valid_string_erwinia_typographi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erwinia_typographi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erwinia_typographi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["371042"]),
        None,
        Some("."),
        Some("NG99_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodobacter sp. SW2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "371731.Rsw2DRAFT_0001";
/// let this_library_node_name2 = "371731.Rsw2DRAFT_3409";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodobacter_sp_sw2_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodobacter_sp_sw2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodobacter_sp_sw2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodobacter_sp_sw2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["371731"]),
        None,
        Some("."),
        Some("Rsw2DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Buchnera aphidicola BCc nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "372461.41323035";
/// let this_library_node_name2 = "372461.BCc_397";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_buchnera_aphidicola_bcc_node_name(this_library_node_name1));
/// assert!(is_valid_string_buchnera_aphidicola_bcc_node_name(this_library_node_name2));
/// assert!(!is_valid_string_buchnera_aphidicola_bcc_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_buchnera_aphidicola_bcc_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["372461"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus pneumoniae D39 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "373153.SPD_0001";
/// let this_library_node_name2 = "373153.SPD_2069";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_pneumoniae_d39_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_pneumoniae_d39_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_pneumoniae_d39_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_pneumoniae_d39_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["373153"]),
        None,
        Some("."),
        Some("SPD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halothermothrix orenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "373903.Hore_00010";
/// let this_library_node_name2 = "373903.Hore_23600";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halothermothrix_orenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_halothermothrix_orenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halothermothrix_orenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halothermothrix_orenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["373903"]),
        None,
        Some("."),
        Some("Hore_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rivularia sp. PCC7116 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "373994.Riv7116_0001";
/// let this_library_node_name2 = "373994.Riv7116_6912";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rivularia_sp_pcc7116_node_name(this_library_node_name1));
/// assert!(is_valid_string_rivularia_sp_pcc7116_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rivularia_sp_pcc7116_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rivularia_sp_pcc7116_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["373994"]),
        None,
        Some("."),
        Some("Riv7116_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Korarchaeum cryptofilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "374847.Kcr_0001";
/// let this_library_node_name2 = "374847.Kcr_1617";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_korarchaeum_cryptofilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_korarchaeum_cryptofilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_korarchaeum_cryptofilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_korarchaeum_cryptofilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["374847"]),
        None,
        Some("."),
        Some("Kcr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Janthinobacterium sp. Marseille nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "375286.mma_0001";
/// let this_library_node_name2 = "375286.mma_3697";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_janthinobacterium_sp_marseille_node_name(this_library_node_name1));
/// assert!(is_valid_string_janthinobacterium_sp_marseille_node_name(this_library_node_name2));
/// assert!(!is_valid_string_janthinobacterium_sp_marseille_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_janthinobacterium_sp_marseille_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["375286"]),
        None,
        Some("."),
        Some("mma_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseobacter denitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "375451.RD1_0003";
/// let this_library_node_name2 = "375451.RD1_B0057";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseobacter_denitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseobacter_denitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseobacter_denitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseobacter_denitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["375451"]),
        None,
        Some("."),
        Some("RD1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Francisella tularensis holarctica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "376619.FTL_0001";
/// let this_library_node_name2 = "376619.FTL_1968";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_francisella_tularensis_holarctica_node_name(this_library_node_name1));
/// assert!(is_valid_string_francisella_tularensis_holarctica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_francisella_tularensis_holarctica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_francisella_tularensis_holarctica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["376619"]),
        None,
        Some("."),
        Some("FTL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium johnsoniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "376686.Fjoh_0001";
/// let this_library_node_name2 = "376686.Fjoh_5056";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_johnsoniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_johnsoniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_johnsoniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_johnsoniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["376686"]),
        None,
        Some("."),
        Some("Fjoh_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus halophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "376733.IT41_00015";
/// let this_library_node_name2 = "376733.IT41_20140";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_halophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_halophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_halophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_halophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["376733"]),
        None,
        Some("."),
        Some("IT41_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Teredinibacter turnerae T7901 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "377629.TERTU_0002";
/// let this_library_node_name2 = "377629.TERTU_4740";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_teredinibacter_turnerae_t7901_node_name(this_library_node_name1));
/// assert!(is_valid_string_teredinibacter_turnerae_t7901_node_name(this_library_node_name2));
/// assert!(!is_valid_string_teredinibacter_turnerae_t7901_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_teredinibacter_turnerae_t7901_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["377629"]),
        None,
        Some("."),
        Some("TERTU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kocuria rhizophila DC2201 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "378753.KRH_00010";
/// let this_library_node_name2 = "378753.KRH_23570";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kocuria_rhizophila_dc2201_node_name(this_library_node_name1));
/// assert!(is_valid_string_kocuria_rhizophila_dc2201_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kocuria_rhizophila_dc2201_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kocuria_rhizophila_dc2201_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["378753"]),
        None,
        Some("."),
        Some("KRH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stigmatella aurantiaca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "378806.STAUR_0001";
/// let this_library_node_name2 = "378806.STAUR_8407";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stigmatella_aurantiaca_node_name(this_library_node_name1));
/// assert!(is_valid_string_stigmatella_aurantiaca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stigmatella_aurantiaca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stigmatella_aurantiaca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["378806"]),
        None,
        Some("."),
        Some("STAUR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemmatimonas aurantiaca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "379066.GAU_0001";
/// let this_library_node_name2 = "379066.GAU_3935";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemmatimonas_aurantiaca_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemmatimonas_aurantiaca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemmatimonas_aurantiaca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemmatimonas_aurantiaca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["379066"]),
        None,
        Some("."),
        Some("GAU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas stutzeri A1501 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "379731.PST_0001";
/// let this_library_node_name2 = "379731.PST_4214";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_stutzeri_a1501_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_stutzeri_a1501_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_stutzeri_a1501_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_stutzeri_a1501_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["379731"]),
        None,
        Some("."),
        Some("PST_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas albilineans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "380358.283473077";
/// let this_library_node_name2 = "380358.XALC_3173";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_albilineans_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_albilineans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_albilineans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_albilineans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["380358"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidithiobacillus ferrooxidans ATCC53993 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "380394.Lferr_0001";
/// let this_library_node_name2 = "380394.Lferr_2904";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidithiobacillus_ferrooxidans_atcc53993_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidithiobacillus_ferrooxidans_atcc53993_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidithiobacillus_ferrooxidans_atcc53993_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidithiobacillus_ferrooxidans_atcc53993_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["380394"]),
        None,
        Some("."),
        Some("Lferr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aeromonas hydrophila ATCC7966 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "380703.AHA_0001";
/// let this_library_node_name2 = "380703.AHA_4287";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aeromonas_hydrophila_atcc7966_node_name(this_library_node_name1));
/// assert!(is_valid_string_aeromonas_hydrophila_atcc7966_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aeromonas_hydrophila_atcc7966_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aeromonas_hydrophila_atcc7966_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["380703"]),
        None,
        Some("."),
        Some("AHA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hydrogenobaculum sp. Y04AAS1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "380749.HY04AAS1_0001";
/// let this_library_node_name2 = "380749.HY04AAS1_1640";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hydrogenobaculum_sp_y04aas1_node_name(this_library_node_name1));
/// assert!(is_valid_string_hydrogenobaculum_sp_y04aas1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hydrogenobaculum_sp_y04aas1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hydrogenobaculum_sp_y04aas1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["380749"]),
        None,
        Some("."),
        Some("HY04AAS1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachancea thermotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "381046.XP_002551474.1";
/// let this_library_node_name2 = "381046.XP_002556564.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachancea_thermotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachancea_thermotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachancea_thermotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachancea_thermotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["381046"]),
        None,
        Some("."),
        Some("XP_00255"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ralstonia eutropha H16 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "381666.H16_A0001";
/// let this_library_node_name2 = "381666.PHG427";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ralstonia_eutropha_h16_node_name(this_library_node_name1));
/// assert!(is_valid_string_ralstonia_eutropha_h16_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ralstonia_eutropha_h16_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ralstonia_eutropha_h16_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["381666"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fervidobacterium nodosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "381764.Fnod_0001";
/// let this_library_node_name2 = "381764.Fnod_1790";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fervidobacterium_nodosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_fervidobacterium_nodosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fervidobacterium_nodosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fervidobacterium_nodosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["381764"]),
        None,
        Some("."),
        Some("Fnod_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aeromonas salmonicida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "382245.32186810";
/// let this_library_node_name2 = "382245.ASA_4388";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aeromonas_salmonicida_node_name(this_library_node_name1));
/// assert!(is_valid_string_aeromonas_salmonicida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aeromonas_salmonicida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aeromonas_salmonicida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["382245"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Verrucomicrobiae bacterium DG1235 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "382464.ABSI01000001_gene4220";
/// let this_library_node_name2 = "382464.ABSI01000026_gene4199";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_verrucomicrobiae_bacterium_dg1235_node_name(this_library_node_name1));
/// assert!(is_valid_string_verrucomicrobiae_bacterium_dg1235_node_name(this_library_node_name2));
/// assert!(!is_valid_string_verrucomicrobiae_bacterium_dg1235_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_verrucomicrobiae_bacterium_dg1235_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["382464"]),
        None,
        Some("."),
        Some("ABSI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter acinonychis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "382638.Hac_0001";
/// let this_library_node_name2 = "382638.pHac1_6";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_acinonychis_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_acinonychis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_acinonychis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_acinonychis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["382638"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella tribocorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "382640.BT0001";
/// let this_library_node_name2 = "382640.pBT01_0018";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_tribocorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_tribocorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_tribocorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_tribocorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["382640"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseiflexus castenholzii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "383372.Rcas_0001";
/// let this_library_node_name2 = "383372.Rcas_4453";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseiflexus_castenholzii_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseiflexus_castenholzii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseiflexus_castenholzii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseiflexus_castenholzii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["383372"]),
        None,
        Some("."),
        Some("Rcas_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erythrobacter sp. JL475 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "383381.EH30_00005";
/// let this_library_node_name2 = "383381.EH30_15960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erythrobacter_sp_jl475_node_name(this_library_node_name1));
/// assert!(is_valid_string_erythrobacter_sp_jl475_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erythrobacter_sp_jl475_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erythrobacter_sp_jl475_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["383381"]),
        None,
        Some("."),
        Some("EH30_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas oryzae oryzicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "383407.XOC_0002";
/// let this_library_node_name2 = "383407.XOC_4689";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_oryzae_oryzicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_oryzae_oryzicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_oryzae_oryzicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_oryzae_oryzicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["383407"]),
        None,
        Some("."),
        Some("XOC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrobaculum islandicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "384616.Pisl_0001";
/// let this_library_node_name2 = "384616.Pisl_2015";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrobaculum_islandicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrobaculum_islandicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrobaculum_islandicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrobaculum_islandicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["384616"]),
        None,
        Some("."),
        Some("Pisl_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas entomophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "384676.PSEEN0001";
/// let this_library_node_name2 = "384676.PSEENCDS526601D";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_entomophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_entomophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_entomophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_entomophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["384676"]),
        None,
        Some("."),
        Some("PSEEN"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Labrenzia aggregata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "384765.SIAM614_00005";
/// let this_library_node_name2 = "384765.SIAM614_31698";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_labrenzia_aggregata_node_name(this_library_node_name1));
/// assert!(is_valid_string_labrenzia_aggregata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_labrenzia_aggregata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_labrenzia_aggregata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["384765"]),
        None,
        Some("."),
        Some("SIAM614_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermophagus xiamenensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "385682.AFSL01000001_gene1992";
/// let this_library_node_name2 = "385682.AFSL01000113_gene2889";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermophagus_xiamenensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermophagus_xiamenensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermophagus_xiamenensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermophagus_xiamenensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["385682"]),
        None,
        Some("."),
        Some("AFSL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeria welshimeri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "386043.lwe0001";
/// let this_library_node_name2 = "386043.lwe2780";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeria_welshimeri_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeria_welshimeri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeria_welshimeri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeria_welshimeri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["386043"]),
        None,
        Some("."),
        Some("lwe"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium novyi NT nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "386415.NT01CX_0001";
/// let this_library_node_name2 = "386415.NT01CX_2436";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_novyi_nt_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_novyi_nt_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_novyi_nt_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_novyi_nt_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["386415"]),
        None,
        Some("."),
        Some("NT01CX_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanobacterium arcticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "386456.JQKN01000001_gene1627";
/// let this_library_node_name2 = "386456.JQKN01000038_gene1227";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanobacterium_arcticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanobacterium_arcticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanobacterium_arcticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanobacterium_arcticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["386456"]),
        None,
        Some("."),
        Some("JQKN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitratiruptor sp. SB1552 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "387092.NIS_0001";
/// let this_library_node_name2 = "387092.NIS_1857";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitratiruptor_sp_sb1552_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitratiruptor_sp_sb1552_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitratiruptor_sp_sb1552_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitratiruptor_sp_sb1552_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["387092"]),
        None,
        Some("."),
        Some("NIS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurovum sp. NBC371 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "387093.SUN_0001";
/// let this_library_node_name2 = "387093.SUN_2466";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurovum_sp_nbc371_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurovum_sp_nbc371_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurovum_sp_nbc371_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurovum_sp_nbc371_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["387093"]),
        None,
        Some("."),
        Some("SUN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus brevis ATCC367 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "387344.LVIS_0001";
/// let this_library_node_name2 = "387344.LVIS_A12";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_brevis_atcc367_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_brevis_atcc367_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_brevis_atcc367_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_brevis_atcc367_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["387344"]),
        None,
        Some("."),
        Some("LVIS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Archaeoglobus sulfaticallidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "387631.Asulf_00001";
/// let this_library_node_name2 = "387631.Asulf_02300";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_archaeoglobus_sulfaticallidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_archaeoglobus_sulfaticallidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_archaeoglobus_sulfaticallidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_archaeoglobus_sulfaticallidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["387631"]),
        None,
        Some("."),
        Some("Asulf_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cupriavidus sp. amp6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "388051.AUFE01000001_gene1906";
/// let this_library_node_name2 = "388051.AUFE01000260_gene348";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cupriavidus_sp_amp6_node_name(this_library_node_name1));
/// assert!(is_valid_string_cupriavidus_sp_amp6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cupriavidus_sp_amp6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cupriavidus_sp_amp6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["388051"]),
        None,
        Some("."),
        Some("AUFE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sagittula stellata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "388399.SSE37_00005";
/// let this_library_node_name2 = "388399.SSE37_25423";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sagittula_stellata_node_name(this_library_node_name1));
/// assert!(is_valid_string_sagittula_stellata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sagittula_stellata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sagittula_stellata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["388399"]),
        None,
        Some("."),
        Some("SSE37_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodobacteraceae bacterium HTCC2150 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "388401.RB2150_00005";
/// let this_library_node_name2 = "388401.RB2150_18407";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodobacteraceae_bacterium_htcc2150_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodobacteraceae_bacterium_htcc2150_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodobacteraceae_bacterium_htcc2150_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodobacteraceae_bacterium_htcc2150_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["388401"]),
        None,
        Some("."),
        Some("RB2150_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Algoriphagus machipongonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "388413.ALPR1_00005";
/// let this_library_node_name2 = "388413.ALPR1_21227";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_algoriphagus_machipongonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_algoriphagus_machipongonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_algoriphagus_machipongonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_algoriphagus_machipongonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["388413"]),
        None,
        Some("."),
        Some("ALPR1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Planktothrix agardhii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "388467.A19Y_0052";
/// let this_library_node_name2 = "388467.A19Y_6004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_planktothrix_agardhii_node_name(this_library_node_name1));
/// assert!(is_valid_string_planktothrix_agardhii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_planktothrix_agardhii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_planktothrix_agardhii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["388467"]),
        None,
        Some("."),
        Some("A19Y_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseobacter sp. SK20926 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "388739.RSK20926_00005";
/// let this_library_node_name2 = "388739.RSK20926_22799";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseobacter_sp_sk20926_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseobacter_sp_sk20926_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseobacter_sp_sk20926_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseobacter_sp_sk20926_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["388739"]),
        None,
        Some("."),
        Some("RSK20926_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sanguinis SK36 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "388919.SSA_0001";
/// let this_library_node_name2 = "388919.SSA_2394";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sanguinis_sk36_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sanguinis_sk36_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sanguinis_sk36_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sanguinis_sk36_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["388919"]),
        None,
        Some("."),
        Some("SSA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas putida W619 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "390235.PputW619_0001";
/// let this_library_node_name2 = "390235.PputW619_5213";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_putida_w619_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_putida_w619_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_putida_w619_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_putida_w619_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["390235"]),
        None,
        Some("."),
        Some("PputW619_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia afzelii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "390236.BafPKo_0001";
/// let this_library_node_name2 = "390236.BafPKo_0870";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_afzelii_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_afzelii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_afzelii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_afzelii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["390236"]),
        None,
        Some("."),
        Some("BafPKo_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus delbrueckii ATCC11842 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "390333.Ldb0001";
/// let this_library_node_name2 = "390333.Ldb2218";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_delbrueckii_atcc11842_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_delbrueckii_atcc11842_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_delbrueckii_atcc11842_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_delbrueckii_atcc11842_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["390333"]),
        None,
        Some("."),
        Some("Ldb"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermotoga petrophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "390874.Tpet_0001";
/// let this_library_node_name2 = "390874.Tpet_1814";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermotoga_petrophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermotoga_petrophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermotoga_petrophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermotoga_petrophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["390874"]),
        None,
        Some("."),
        Some("Tpet_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinocatenispora sera nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "390989.JOEG01000001_gene4782";
/// let this_library_node_name2 = "390989.JOEG01000077_gene5444";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinocatenispora_sera_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinocatenispora_sera_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinocatenispora_sera_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinocatenispora_sera_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["390989"]),
        None,
        Some("."),
        Some("JOEG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stenotrophomonas maltophilia R5513 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391008.Smal_0001";
/// let this_library_node_name2 = "391008.Smal_4045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stenotrophomonas_maltophilia_r5513_node_name(this_library_node_name1));
/// assert!(is_valid_string_stenotrophomonas_maltophilia_r5513_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stenotrophomonas_maltophilia_r5513_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stenotrophomonas_maltophilia_r5513_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391008"]),
        None,
        Some("."),
        Some("Smal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermosipho melanesiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391009.Tmel_0001";
/// let this_library_node_name2 = "391009.Tmel_1929";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermosipho_melanesiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermosipho_melanesiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermosipho_melanesiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermosipho_melanesiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391009"]),
        None,
        Some("."),
        Some("Tmel_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ehrlichia sp. HF nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391036.EHF_0001";
/// let this_library_node_name2 = "391036.EHF_0999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ehrlichia_sp_hf_node_name(this_library_node_name1));
/// assert!(is_valid_string_ehrlichia_sp_hf_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ehrlichia_sp_hf_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ehrlichia_sp_hf_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391036"]),
        None,
        Some("."),
        Some("EHF_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinispora arenicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391037.Sare_0001";
/// let this_library_node_name2 = "391037.Sare_5111";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinispora_arenicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinispora_arenicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinispora_arenicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinispora_arenicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391037"]),
        None,
        Some("."),
        Some("Sare_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia phymatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391038.Bphy_0001";
/// let this_library_node_name2 = "391038.Bphy_7821";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_phymatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_phymatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_phymatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_phymatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391038"]),
        None,
        Some("."),
        Some("Bphy_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Granulibacter bethesdensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391165.GbCGDNIH1_0001";
/// let this_library_node_name2 = "391165.GbCGDNIH1_2437";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_granulibacter_bethesdensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_granulibacter_bethesdensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_granulibacter_bethesdensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_granulibacter_bethesdensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391165"]),
        None,
        Some("."),
        Some("GbCGDNIH1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus suis 05ZYH33 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391295.SSU05_0001";
/// let this_library_node_name2 = "391295.SSU05_2194";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_suis_05zyh33_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_suis_05zyh33_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_suis_05zyh33_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_suis_05zyh33_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391295"]),
        None,
        Some("."),
        Some("SSU05_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kordia algicida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391587.KAOT1_00005";
/// let this_library_node_name2 = "391587.KAOT1_22686";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kordia_algicida_node_name(this_library_node_name1));
/// assert!(is_valid_string_kordia_algicida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kordia_algicida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kordia_algicida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391587"]),
        None,
        Some("."),
        Some("KAOT1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseobacter sp. GAI101 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391589.RGAI101_1";
/// let this_library_node_name2 = "391589.RGAI101_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseobacter_sp_gai101_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseobacter_sp_gai101_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseobacter_sp_gai101_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseobacter_sp_gai101_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391589"]),
        None,
        Some("."),
        Some("RGAI101_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseobacter sp. CCS2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391593.RCCS2_00005";
/// let this_library_node_name2 = "391593.RCCS2_18356";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseobacter_sp_ccs2_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseobacter_sp_ccs2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseobacter_sp_ccs2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseobacter_sp_ccs2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391593"]),
        None,
        Some("."),
        Some("RCCS2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseobacter litoralis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391595.RLO149_c000010";
/// let this_library_node_name2 = "391595.RLO149_p630640";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseobacter_litoralis_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseobacter_litoralis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseobacter_litoralis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseobacter_litoralis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391595"]),
        None,
        Some("."),
        Some("RLO149_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pedobacter sp. BAL39 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391596.PBAL39_00005";
/// let this_library_node_name2 = "391596.PBAL39_25640";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pedobacter_sp_bal39_node_name(this_library_node_name1));
/// assert!(is_valid_string_pedobacter_sp_bal39_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pedobacter_sp_bal39_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pedobacter_sp_bal39_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391596"]),
        None,
        Some("."),
        Some("PBAL39_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacteria bacterium BAL38 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391598.FBBAL38_00005";
/// let this_library_node_name2 = "391598.FBBAL38_13140";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacteria_bacterium_bal38_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacteria_bacterium_bal38_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacteria_bacterium_bal38_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacteria_bacterium_bal38_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391598"]),
        None,
        Some("."),
        Some("FBBAL38_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevundimonas sp. BAL3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391600.ABRU01000001_gene2874";
/// let this_library_node_name2 = "391600.ABRU01000063_gene2026";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevundimonas_sp_bal3_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevundimonas_sp_bal3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevundimonas_sp_bal3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevundimonas_sp_bal3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391600"]),
        None,
        Some("."),
        Some("ABRU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacteriales bacterium ALC1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391603.FBALC1_00005";
/// let this_library_node_name2 = "391603.FBALC1_17307";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacteriales_bacterium_alc1_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacteriales_bacterium_alc1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacteriales_bacterium_alc1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacteriales_bacterium_alc1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391603"]),
        None,
        Some("."),
        Some("FBALC1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanothece sp. CCY0110 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391612.CY0110_00005";
/// let this_library_node_name2 = "391612.CY0110_32465";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanothece_sp_ccy0110_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanothece_sp_ccy0110_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanothece_sp_ccy0110_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanothece_sp_ccy0110_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391612"]),
        None,
        Some("."),
        Some("CY0110_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseovarius sp. TM1035 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391613.RTM1035_00005";
/// let this_library_node_name2 = "391613.RTM1035_20606";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseovarius_sp_tm1035_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseovarius_sp_tm1035_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseovarius_sp_tm1035_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseovarius_sp_tm1035_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391613"]),
        None,
        Some("."),
        Some("RTM1035_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium HTCC5015 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391615.ABSJ01000001_gene419";
/// let this_library_node_name2 = "391615.ABSJ01000062_gene2324";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_htcc5015_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_htcc5015_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_htcc5015_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_htcc5015_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391615"]),
        None,
        Some("."),
        Some("ABSJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Octadecabacter arcticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391616.OA238_160p0010";
/// let this_library_node_name2 = "391616.OA238_c48690";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_octadecabacter_arcticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_octadecabacter_arcticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_octadecabacter_arcticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_octadecabacter_arcticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391616"]),
        None,
        Some("."),
        Some("OA238_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phaeobacter inhibens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391619.PGA1_262p00010";
/// let this_library_node_name2 = "391619.PGA1_c36510";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phaeobacter_inhibens_node_name(this_library_node_name1));
/// assert!(is_valid_string_phaeobacter_inhibens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phaeobacter_inhibens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phaeobacter_inhibens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391619"]),
        None,
        Some("."),
        Some("PGA1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermococcus barophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391623.TERMP_00001";
/// let this_library_node_name2 = "391623.TERMP_02270";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermococcus_barophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermococcus_barophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermococcus_barophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermococcus_barophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391623"]),
        None,
        Some("."),
        Some("TERMP_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanibulbus indolifex nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391624.OIHEL45_00005";
/// let this_library_node_name2 = "391624.OIHEL45_20851";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanibulbus_indolifex_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanibulbus_indolifex_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanibulbus_indolifex_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanibulbus_indolifex_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391624"]),
        None,
        Some("."),
        Some("OIHEL45_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Plesiocystis pacifica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391625.PPSIR1_00005";
/// let this_library_node_name2 = "391625.PPSIR1_42402";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_plesiocystis_pacifica_node_name(this_library_node_name1));
/// assert!(is_valid_string_plesiocystis_pacifica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_plesiocystis_pacifica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_plesiocystis_pacifica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391625"]),
        None,
        Some("."),
        Some("PPSIR1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Octadecabacter antarcticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391626.OAN307_63p00010";
/// let this_library_node_name2 = "391626.OAN307_c48790";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_octadecabacter_antarcticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_octadecabacter_antarcticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_octadecabacter_antarcticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_octadecabacter_antarcticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391626"]),
        None,
        Some("."),
        Some("OAN307_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Verminephrobacter eiseniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391735.Veis_0001";
/// let this_library_node_name2 = "391735.Veis_5054";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_verminephrobacter_eiseniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_verminephrobacter_eiseniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_verminephrobacter_eiseniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_verminephrobacter_eiseniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391735"]),
        None,
        Some("."),
        Some("Veis_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia bellii OSU85389 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391896.A1I_00005";
/// let this_library_node_name2 = "391896.A1I_07950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_bellii_osu85389_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_bellii_osu85389_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_bellii_osu85389_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_bellii_osu85389_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391896"]),
        None,
        Some("."),
        Some("A1I_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitratireductor pacificus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "391937.NA2_00005";
/// let this_library_node_name2 = "391937.NA2_21123";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitratireductor_pacificus_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitratireductor_pacificus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitratireductor_pacificus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitratireductor_pacificus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["391937"]),
        None,
        Some("."),
        Some("NA2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas wittichii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "392499.Swit_0001";
/// let this_library_node_name2 = "392499.Swit_5400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_wittichii_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_wittichii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_wittichii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_wittichii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["392499"]),
        None,
        Some("."),
        Some("Swit_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella woodyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "392500.Swoo_0001";
/// let this_library_node_name2 = "392500.Swoo_4932";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_woodyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_woodyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_woodyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_woodyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["392500"]),
        None,
        Some("."),
        Some("Swoo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pestalotiopsis fici nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "393283.XP_007826773.1";
/// let this_library_node_name2 = "393283.XP_007842185.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pestalotiopsis_fici_node_name(this_library_node_name1));
/// assert!(is_valid_string_pestalotiopsis_fici_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pestalotiopsis_fici_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pestalotiopsis_fici_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["393283"]),
        None,
        Some("."),
        Some("XP_0078"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yersinia enterocolitica 8081 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "393305.YE0001";
/// let this_library_node_name2 = "393305.YEP0097";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yersinia_enterocolitica_8081_node_name(this_library_node_name1));
/// assert!(is_valid_string_yersinia_enterocolitica_8081_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yersinia_enterocolitica_8081_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yersinia_enterocolitica_8081_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["393305"]),
        None,
        Some("."),
        Some("YE"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium nucleatum polymorphum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "393480.FNP_0001";
/// let this_library_node_name2 = "393480.FNP_2433";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_nucleatum_polymorphum_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_nucleatum_polymorphum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_nucleatum_polymorphum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_nucleatum_polymorphum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["393480"]),
        None,
        Some("."),
        Some("FNP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alcanivorax borkumensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "393595.ABO_0001";
/// let this_library_node_name2 = "393595.ABO_2755";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alcanivorax_borkumensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alcanivorax_borkumensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alcanivorax_borkumensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alcanivorax_borkumensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["393595"]),
        None,
        Some("."),
        Some("ABO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas crevioricanis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "393921.HQ45_00010";
/// let this_library_node_name2 = "393921.HQ45_09730";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_crevioricanis_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_crevioricanis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_crevioricanis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_crevioricanis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["393921"]),
        None,
        Some("."),
        Some("HQ45_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Maricaulis maris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "394221.Mmar10_0001";
/// let this_library_node_name2 = "394221.Mmar10_3080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_maricaulis_maris_node_name(this_library_node_name1));
/// assert!(is_valid_string_maricaulis_maris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_maricaulis_maris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_maricaulis_maris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["394221"]),
        None,
        Some("."),
        Some("Mmar10_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium cellulolyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "394503.Ccel_0001";
/// let this_library_node_name2 = "394503.Ccel_3491";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_cellulolyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_cellulolyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_cellulolyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_cellulolyticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["394503"]),
        None,
        Some("."),
        Some("Ccel_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia multivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "395019.Bmul_0001";
/// let this_library_node_name2 = "395019.Bmul_6301";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_multivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_multivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_multivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_multivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["395019"]),
        None,
        Some("."),
        Some("Bmul_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium leguminosarum WSM2304 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "395492.Rleg2_0001";
/// let this_library_node_name2 = "395492.Rleg2_5614";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_leguminosarum_wsm2304_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_leguminosarum_wsm2304_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_leguminosarum_wsm2304_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_leguminosarum_wsm2304_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["395492"]),
        None,
        Some("."),
        Some("Rleg2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Beggiatoa alba nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "395493.BegalDRAFT_0001";
/// let this_library_node_name2 = "395493.BegalDRAFT_3572";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_beggiatoa_alba_node_name(this_library_node_name1));
/// assert!(is_valid_string_beggiatoa_alba_node_name(this_library_node_name2));
/// assert!(!is_valid_string_beggiatoa_alba_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_beggiatoa_alba_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["395493"]),
        None,
        Some("."),
        Some("BegalDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gallionella capsiferriformans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "395494.Galf_0001";
/// let this_library_node_name2 = "395494.Galf_2947";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gallionella_capsiferriformans_node_name(this_library_node_name1));
/// assert!(is_valid_string_gallionella_capsiferriformans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gallionella_capsiferriformans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gallionella_capsiferriformans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["395494"]),
        None,
        Some("."),
        Some("Galf_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptothrix cholodnii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "395495.Lcho_0001";
/// let this_library_node_name2 = "395495.Lcho_4388";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptothrix_cholodnii_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptothrix_cholodnii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptothrix_cholodnii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptothrix_cholodnii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["395495"]),
        None,
        Some("."),
        Some("Lcho_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanothece sp. PCC7425 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "395961.Cyan7425_0001";
/// let this_library_node_name2 = "395961.Cyan7425_5268";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanothece_sp_pcc7425_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanothece_sp_pcc7425_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanothece_sp_pcc7425_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanothece_sp_pcc7425_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["395961"]),
        None,
        Some("."),
        Some("Cyan7425_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Beijerinckia indica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "395963.Bind_0001";
/// let this_library_node_name2 = "395963.Bind_3918";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_beijerinckia_indica_node_name(this_library_node_name1));
/// assert!(is_valid_string_beijerinckia_indica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_beijerinckia_indica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_beijerinckia_indica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["395963"]),
        None,
        Some("."),
        Some("Bind_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylocapsa acidiphila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "395964.KE386496_gene1";
/// let this_library_node_name2 = "395964.KE386496_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylocapsa_acidiphila_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylocapsa_acidiphila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylocapsa_acidiphila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylocapsa_acidiphila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["395964"]),
        None,
        Some("."),
        Some("KE386496_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylocella silvestris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "395965.Msil_0001";
/// let this_library_node_name2 = "395965.Msil_3922";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylocella_silvestris_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylocella_silvestris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylocella_silvestris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylocella_silvestris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["395965"]),
        None,
        Some("."),
        Some("Msil_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachybacterium phenoliresistens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "396014.BF93_00010";
/// let this_library_node_name2 = "396014.BF93_18995";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachybacterium_phenoliresistens_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachybacterium_phenoliresistens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachybacterium_phenoliresistens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachybacterium_phenoliresistens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["396014"]),
        None,
        Some("."),
        Some("BF93_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus carnosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "396513.SCA_0001";
/// let this_library_node_name2 = "396513.SCA_2474";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_carnosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_carnosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_carnosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_carnosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["396513"]),
        None,
        Some("."),
        Some("SCA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sulfidiphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "396588.Tgr7_0001";
/// let this_library_node_name2 = "396588.Tgr7_3321";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sulfidiphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sulfidiphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sulfidiphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sulfidiphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["396588"]),
        None,
        Some("."),
        Some("Tgr7_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. K90mix nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "396595.TK90_0001";
/// let this_library_node_name2 = "396595.TK90_2888";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_k90mix_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_k90mix_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_k90mix_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_k90mix_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["396595"]),
        None,
        Some("."),
        Some("TK90_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marmoricola aequoreus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "397278.JOJN01000001_gene2588";
/// let this_library_node_name2 = "397278.JOJN01000043_gene3786";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marmoricola_aequoreus_node_name(this_library_node_name1));
/// assert!(is_valid_string_marmoricola_aequoreus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marmoricola_aequoreus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marmoricola_aequoreus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["397278"]),
        None,
        Some("."),
        Some("JOJN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium 284 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "397287.C807_00001";
/// let this_library_node_name2 = "397287.C807_04079";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_284_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_284_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_284_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_284_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["397287"]),
        None,
        Some("."),
        Some("C807_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium 31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "397288.C806_00001";
/// let this_library_node_name2 = "397288.C806_05142";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_31_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["397288"]),
        None,
        Some("."),
        Some("C806_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium A2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "397290.C810_00001";
/// let this_library_node_name2 = "397290.C810_05283";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_a2_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_a2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_a2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_a2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["397290"]),
        None,
        Some("."),
        Some("C810_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium A4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "397291.C804_00001";
/// let this_library_node_name2 = "397291.C804_06624";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_a4_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_a4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_a4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_a4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["397291"]),
        None,
        Some("."),
        Some("C804_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidovorax citrulli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "397945.Aave_0001";
/// let this_library_node_name2 = "397945.Aave_4796";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidovorax_citrulli_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidovorax_citrulli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidovorax_citrulli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidovorax_citrulli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["397945"]),
        None,
        Some("."),
        Some("Aave_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldivirga maquilingensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "397948.Cmaq_0001";
/// let this_library_node_name2 = "397948.Cmaq_2002";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldivirga_maquilingensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldivirga_maquilingensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldivirga_maquilingensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldivirga_maquilingensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["397948"]),
        None,
        Some("."),
        Some("Cmaq_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus pseudofirmus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "398511.BpOF4_00005";
/// let this_library_node_name2 = "398511.BpOF4_21434";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_pseudofirmus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_pseudofirmus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_pseudofirmus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_pseudofirmus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["398511"]),
        None,
        Some("."),
        Some("BpOF4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudobacteroides cellulosolvens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "398512.JQKC01000001_gene2037";
/// let this_library_node_name2 = "398512.JQKC01000126_gene4783";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudobacteroides_cellulosolvens_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudobacteroides_cellulosolvens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudobacteroides_cellulosolvens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudobacteroides_cellulosolvens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["398512"]),
        None,
        Some("."),
        Some("JQKC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium bifidum NCIMB41171 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "398513.BBNG_00001";
/// let this_library_node_name2 = "398513.BBNG_01854";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_bifidum_ncimb41171_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_bifidum_ncimb41171_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_bifidum_ncimb41171_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_bifidum_ncimb41171_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["398513"]),
        None,
        Some("."),
        Some("BBNG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium elkanii USDA76 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "398525.KB900701_gene1000";
/// let this_library_node_name2 = "398525.KB900702_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_elkanii_usda76_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_elkanii_usda76_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_elkanii_usda76_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_elkanii_usda76_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["398525"]),
        None,
        Some("."),
        Some("KB90070"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia phytofirmans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "398527.Bphyt_0001";
/// let this_library_node_name2 = "398527.Bphyt_7409";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_phytofirmans_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_phytofirmans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_phytofirmans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_phytofirmans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["398527"]),
        None,
        Some("."),
        Some("Bphyt_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Delftia acidovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "398578.Daci_0001";
/// let this_library_node_name2 = "398578.Daci_6059";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_delftia_acidovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_delftia_acidovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_delftia_acidovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_delftia_acidovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["398578"]),
        None,
        Some("."),
        Some("Daci_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella pealeana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "398579.Spea_0001";
/// let this_library_node_name2 = "398579.Spea_4260";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_pealeana_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_pealeana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_pealeana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_pealeana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["398579"]),
        None,
        Some("."),
        Some("Spea_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dinoroseobacter shibae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "398580.Dshi_0001";
/// let this_library_node_name2 = "398580.Dshi_5008";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dinoroseobacter_shibae_node_name(this_library_node_name1));
/// assert!(is_valid_string_dinoroseobacter_shibae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dinoroseobacter_shibae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dinoroseobacter_shibae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["398580"]),
        None,
        Some("."),
        Some("Dshi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leeuwenhoekiella blandensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "398720.MED217_00005";
/// let this_library_node_name2 = "398720.MED217_18761";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leeuwenhoekiella_blandensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_leeuwenhoekiella_blandensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leeuwenhoekiella_blandensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leeuwenhoekiella_blandensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["398720"]),
        None,
        Some("."),
        Some("MED217_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacter lovleyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "398767.Glov_0001";
/// let this_library_node_name2 = "398767.Glov_3726";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacter_lovleyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacter_lovleyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacter_lovleyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacter_lovleyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["398767"]),
        None,
        Some("."),
        Some("Glov_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Metallosphaera sedula nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "399549.Msed_0001";
/// let this_library_node_name2 = "399549.Msed_2296";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_metallosphaera_sedula_node_name(this_library_node_name1));
/// assert!(is_valid_string_metallosphaera_sedula_node_name(this_library_node_name2));
/// assert!(!is_valid_string_metallosphaera_sedula_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_metallosphaera_sedula_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["399549"]),
        None,
        Some("."),
        Some("Msed_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylothermus marinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "399550.Smar_0001";
/// let this_library_node_name2 = "399550.Smar_1601";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylothermus_marinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylothermus_marinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylothermus_marinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylothermus_marinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["399550"]),
        None,
        Some("."),
        Some("Smar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas mendocina ymp nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "399739.Pmen_0001";
/// let this_library_node_name2 = "399739.Pmen_4623";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_mendocina_ymp_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_mendocina_ymp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_mendocina_ymp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_mendocina_ymp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["399739"]),
        None,
        Some("."),
        Some("Pmen_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia proteamaculans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "399741.Spro_0001";
/// let this_library_node_name2 = "399741.Spro_4960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_proteamaculans_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_proteamaculans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_proteamaculans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_proteamaculans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["399741"]),
        None,
        Some("."),
        Some("Spro_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacter sp. 638 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "399742.Ent638_0001";
/// let this_library_node_name2 = "399742.Ent638_4325";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacter_sp_638_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacter_sp_638_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacter_sp_638_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacter_sp_638_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["399742"]),
        None,
        Some("."),
        Some("Ent638_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Comamonas testosteroni KF1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "399795.CtesDRAFT_PD0001";
/// let this_library_node_name2 = "399795.CtesDRAFT_PD5494";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_comamonas_testosteroni_kf1_node_name(this_library_node_name1));
/// assert!(is_valid_string_comamonas_testosteroni_kf1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_comamonas_testosteroni_kf1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_comamonas_testosteroni_kf1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["399795"]),
        None,
        Some("."),
        Some("CtesDRAFT_PD"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinomonas sp. MWYL1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "400668.Mmwyl1_0001";
/// let this_library_node_name2 = "400668.Mmwyl1_4487";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinomonas_sp_mwyl1_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinomonas_sp_mwyl1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinomonas_sp_mwyl1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinomonas_sp_mwyl1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["400668"]),
        None,
        Some("."),
        Some("Mmwyl1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amphimedon queenslandica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "400682.PAC_15698531";
/// let this_library_node_name2 = "400682.PAC_15728855";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amphimedon_queenslandica_node_name(this_library_node_name1));
/// assert!(is_valid_string_amphimedon_queenslandica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amphimedon_queenslandica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amphimedon_queenslandica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["400682"]),
        None,
        Some("."),
        Some("PAC_15"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Terriglobus saanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "401053.AciPR4_0001";
/// let this_library_node_name2 = "401053.AciPR4_4279";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_terriglobus_saanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_terriglobus_saanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_terriglobus_saanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_terriglobus_saanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["401053"]),
        None,
        Some("."),
        Some("AciPR4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium dentium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "401473.BDP_0001";
/// let this_library_node_name2 = "401473.BDP_4003";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_dentium_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_dentium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_dentium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_dentium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["401473"]),
        None,
        Some("."),
        Some("BDP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermosinus carboxydivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "401526.TcarDRAFT_0001";
/// let this_library_node_name2 = "401526.TcarDRAFT_2750";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermosinus_carboxydivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermosinus_carboxydivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermosinus_carboxydivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermosinus_carboxydivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["401526"]),
        None,
        Some("."),
        Some("TcarDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium psychrophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "402612.FP0001";
/// let this_library_node_name2 = "402612.FP2633";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_psychrophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_psychrophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_psychrophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_psychrophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["402612"]),
        None,
        Some("."),
        Some("FP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ralstonia pickettii 12J nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "402626.Rpic_0001";
/// let this_library_node_name2 = "402626.Rpic_5038";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ralstonia_pickettii_12j_node_name(this_library_node_name1));
/// assert!(is_valid_string_ralstonia_pickettii_12j_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ralstonia_pickettii_12j_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ralstonia_pickettii_12j_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["402626"]),
        None,
        Some("."),
        Some("Rpic_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kamptonema formosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "402777.KB235898_gene4917";
/// let this_library_node_name2 = "402777.KB235909_gene4916";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kamptonema_formosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_kamptonema_formosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kamptonema_formosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kamptonema_formosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["402777"]),
        None,
        Some("."),
        Some("KB235"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanococcus maripaludis C5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "402880.MmarC5_0001";
/// let this_library_node_name2 = "402880.MmarC5_1848";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanococcus_maripaludis_c5_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanococcus_maripaludis_c5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanococcus_maripaludis_c5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanococcus_maripaludis_c5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["402880"]),
        None,
        Some("."),
        Some("MmarC5_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parvibaculum lavamentivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "402881.Plav_0001";
/// let this_library_node_name2 = "402881.Plav_3661";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parvibaculum_lavamentivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_parvibaculum_lavamentivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parvibaculum_lavamentivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parvibaculum_lavamentivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["402881"]),
        None,
        Some("."),
        Some("Plav_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Petrotoga mobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "403833.Pmob_0001";
/// let this_library_node_name2 = "403833.Pmob_1960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_petrotoga_mobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_petrotoga_mobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_petrotoga_mobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_petrotoga_mobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["403833"]),
        None,
        Some("."),
        Some("Pmob_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacter bemidjiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "404380.Gbem_0001";
/// let this_library_node_name2 = "404380.Gbem_4151";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacter_bemidjiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacter_bemidjiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacter_bemidjiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacter_bemidjiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["404380"]),
        None,
        Some("."),
        Some("Gbem_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaeromyxobacter sp. Fw1095 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "404589.Anae109_0001";
/// let this_library_node_name2 = "404589.Anae109_4508";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaeromyxobacter_sp_fw1095_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaeromyxobacter_sp_fw1095_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaeromyxobacter_sp_fw1095_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaeromyxobacter_sp_fw1095_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["404589"]),
        None,
        Some("."),
        Some("Anae109_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus helveticus DPC4571 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "405566.lhv_0001";
/// let this_library_node_name2 = "405566.lhv_2938";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_helveticus_dpc4571_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_helveticus_dpc4571_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_helveticus_dpc4571_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_helveticus_dpc4571_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["405566"]),
        None,
        Some("."),
        Some("lhv_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharopolyspora erythraea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "405948.SACE_0001";
/// let this_library_node_name2 = "405948.SACE_7397";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharopolyspora_erythraea_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharopolyspora_erythraea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharopolyspora_erythraea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharopolyspora_erythraea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["405948"]),
        None,
        Some("."),
        Some("SACE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. m313 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "406124.ACPC01000001_gene1844";
/// let this_library_node_name2 = "406124.ACPC01000050_gene509";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_m313_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_m313_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_m313_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_m313_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["406124"]),
        None,
        Some("."),
        Some("ACPC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanococcus vannielii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "406327.Mevan_0001";
/// let this_library_node_name2 = "406327.Mevan_1701";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanococcus_vannielii_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanococcus_vannielii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanococcus_vannielii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanococcus_vannielii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["406327"]),
        None,
        Some("."),
        Some("Mevan_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natrinema sp. J72 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "406552.NJ7G_0005";
/// let this_library_node_name2 = "406552.NJ7G_4378";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natrinema_sp_j72_node_name(this_library_node_name1));
/// assert!(is_valid_string_natrinema_sp_j72_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natrinema_sp_j72_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natrinema_sp_j72_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["406552"]),
        None,
        Some("."),
        Some("NJ7G_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xenorhabdus nematophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "406817.XNC1_0001";
/// let this_library_node_name2 = "406817.XNC1_p0191";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xenorhabdus_nematophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_xenorhabdus_nematophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xenorhabdus_nematophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xenorhabdus_nematophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["406817"]),
        None,
        Some("."),
        Some("XNC1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xenorhabdus bovienii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "406818.XBJ1_0001";
/// let this_library_node_name2 = "406818.XBJ1_4414";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xenorhabdus_bovienii_node_name(this_library_node_name1));
/// assert!(is_valid_string_xenorhabdus_bovienii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xenorhabdus_bovienii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xenorhabdus_bovienii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["406818"]),
        None,
        Some("."),
        Some("XBJ1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardioidaceae bacterium Broad1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "408672.NBCG_00001";
/// let this_library_node_name2 = "408672.NBCG_05745";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardioidaceae_bacterium_broad1_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardioidaceae_bacterium_broad1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardioidaceae_bacterium_broad1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardioidaceae_bacterium_broad1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["408672"]),
        None,
        Some("."),
        Some("NBCG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanocorpusculum labreanum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "410358.Mlab_0001";
/// let this_library_node_name2 = "410358.Mlab_1756";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanocorpusculum_labreanum_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanocorpusculum_labreanum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanocorpusculum_labreanum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanocorpusculum_labreanum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["410358"]),
        None,
        Some("."),
        Some("Mlab_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrobaculum calidifontis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "410359.Pcal_0001";
/// let this_library_node_name2 = "410359.Pcal_2174";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrobaculum_calidifontis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrobaculum_calidifontis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrobaculum_calidifontis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrobaculum_calidifontis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["410359"]),
        None,
        Some("."),
        Some("Pcal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gramella forsetii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411154.GFO_0001";
/// let this_library_node_name2 = "411154.GFO_3637";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gramella_forsetii_node_name(this_library_node_name1));
/// assert!(is_valid_string_gramella_forsetii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gramella_forsetii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gramella_forsetii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411154"]),
        None,
        Some("."),
        Some("GFO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus obeum ATCC29174 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411459.RUMOBE_00001";
/// let this_library_node_name2 = "411459.RUMOBE_04231";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_obeum_atcc29174_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_obeum_atcc29174_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_obeum_atcc29174_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_obeum_atcc29174_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411459"]),
        None,
        Some("."),
        Some("RUMOBE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus torques ATCC27756 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411460.RUMTOR_00001";
/// let this_library_node_name2 = "411460.RUMTOR_02929";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_torques_atcc27756_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_torques_atcc27756_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_torques_atcc27756_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_torques_atcc27756_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411460"]),
        None,
        Some("."),
        Some("RUMTOR_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dorea formicigenerans ATCC27755 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411461.DORFOR_00001";
/// let this_library_node_name2 = "411461.DORFOR_03342";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dorea_formicigenerans_atcc27755_node_name(this_library_node_name1));
/// assert!(is_valid_string_dorea_formicigenerans_atcc27755_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dorea_formicigenerans_atcc27755_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dorea_formicigenerans_atcc27755_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411461"]),
        None,
        Some("."),
        Some("DORFOR_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dorea longicatena DSM13814 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411462.DORLON_00001";
/// let this_library_node_name2 = "411462.DORLON_03034";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dorea_longicatena_dsm13814_node_name(this_library_node_name1));
/// assert!(is_valid_string_dorea_longicatena_dsm13814_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dorea_longicatena_dsm13814_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dorea_longicatena_dsm13814_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411462"]),
        None,
        Some("."),
        Some("DORLON_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium ventriosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411463.EUBVEN_00001";
/// let this_library_node_name2 = "411463.EUBVEN_02881";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_ventriosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_ventriosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_ventriosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_ventriosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411463"]),
        None,
        Some("."),
        Some("EUBVEN_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio piger nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411464.DESPIG_00001";
/// let this_library_node_name2 = "411464.DESPIG_03185";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_piger_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_piger_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_piger_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_piger_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411464"]),
        None,
        Some("."),
        Some("DESPIG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parvimonas micra nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411465.PEPMIC_00001";
/// let this_library_node_name2 = "411465.PEPMIC_01711";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parvimonas_micra_node_name(this_library_node_name1));
/// assert!(is_valid_string_parvimonas_micra_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parvimonas_micra_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parvimonas_micra_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411465"]),
        None,
        Some("."),
        Some("PEPMIC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces odontolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411466.ACTODO_00001";
/// let this_library_node_name2 = "411466.ACTODO_02213";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_odontolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_odontolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_odontolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_odontolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411466"]),
        None,
        Some("."),
        Some("ACTODO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoflavonifractor capillosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411467.BACCAP_00001";
/// let this_library_node_name2 = "411467.BACCAP_04902";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoflavonifractor_capillosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoflavonifractor_capillosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoflavonifractor_capillosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoflavonifractor_capillosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411467"]),
        None,
        Some("."),
        Some("BACCAP_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium scindens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411468.CLOSCI_00001";
/// let this_library_node_name2 = "411468.CLOSCI_04078";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_scindens_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_scindens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_scindens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_scindens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411468"]),
        None,
        Some("."),
        Some("CLOSCI_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium hallii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411469.EUBHAL_00001";
/// let this_library_node_name2 = "411469.EUBHAL_03300";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_hallii_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_hallii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_hallii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_hallii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411469"]),
        None,
        Some("."),
        Some("EUBHAL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus gnavus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411470.RUMGNA_00001";
/// let this_library_node_name2 = "411470.RUMGNA_03974";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_gnavus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_gnavus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_gnavus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_gnavus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411470"]),
        None,
        Some("."),
        Some("RUMGNA_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Subdoligranulum variabile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411471.SUBVAR_04000";
/// let this_library_node_name2 = "411471.SUBVAR_07450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_subdoligranulum_variabile_node_name(this_library_node_name1));
/// assert!(is_valid_string_subdoligranulum_variabile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_subdoligranulum_variabile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_subdoligranulum_variabile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411471"]),
        None,
        Some("."),
        Some("SUBVAR_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus callidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411473.RUMCAL_00001";
/// let this_library_node_name2 = "411473.RUMCAL_03532";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_callidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_callidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_callidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_callidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411473"]),
        None,
        Some("."),
        Some("RUMCAL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coprococcus eutactus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411474.COPEUT_00001";
/// let this_library_node_name2 = "411474.COPEUT_03051";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coprococcus_eutactus_node_name(this_library_node_name1));
/// assert!(is_valid_string_coprococcus_eutactus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coprococcus_eutactus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coprococcus_eutactus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411474"]),
        None,
        Some("."),
        Some("COPEUT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides ovatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411476.BACOVA_00001";
/// let this_library_node_name2 = "411476.BACOVA_05622";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_ovatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_ovatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_ovatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_ovatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411476"]),
        None,
        Some("."),
        Some("BACOVA_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parabacteroides merdae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411477.PARMER_00001";
/// let this_library_node_name2 = "411477.PARMER_04469";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parabacteroides_merdae_node_name(this_library_node_name1));
/// assert!(is_valid_string_parabacteroides_merdae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parabacteroides_merdae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parabacteroides_merdae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411477"]),
        None,
        Some("."),
        Some("PARMER_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides uniformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411479.BACUNI_00001";
/// let this_library_node_name2 = "411479.BACUNI_04727";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_uniformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_uniformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_uniformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_uniformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411479"]),
        None,
        Some("."),
        Some("BACUNI_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Faecalibacterium prausnitzii A2165 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411483.FAEPRAA2165_00001";
/// let this_library_node_name2 = "411483.FAEPRAA2165_03554";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_faecalibacterium_prausnitzii_a2165_node_name(this_library_node_name1));
/// assert!(is_valid_string_faecalibacterium_prausnitzii_a2165_node_name(this_library_node_name2));
/// assert!(!is_valid_string_faecalibacterium_prausnitzii_a2165_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_faecalibacterium_prausnitzii_a2165_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411483"]),
        None,
        Some("."),
        Some("FAEPRAA2165_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. L250 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411489.CLOL250_00001";
/// let this_library_node_name2 = "411489.CLOL250_03003";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_l250_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_l250_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_l250_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_l250_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411489"]),
        None,
        Some("."),
        Some("CLOL250_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerostipes caccae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411490.ANACAC_00001";
/// let this_library_node_name2 = "411490.ANACAC_03838";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerostipes_caccae_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerostipes_caccae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerostipes_caccae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerostipes_caccae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411490"]),
        None,
        Some("."),
        Some("ANACAC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hoeflea phototrophica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411684.HPDFL43_00002000";
/// let this_library_node_name2 = "411684.HPDFL43_21874";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hoeflea_phototrophica_node_name(this_library_node_name1));
/// assert!(is_valid_string_hoeflea_phototrophica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hoeflea_phototrophica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hoeflea_phototrophica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411684"]),
        None,
        Some("."),
        Some("HPDFL43_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides caccae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411901.BACCAC_00001";
/// let this_library_node_name2 = "411901.BACCAC_03937";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_caccae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_caccae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_caccae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_caccae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411901"]),
        None,
        Some("."),
        Some("BACCAC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium bolteae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "411902.CLOBOL_00001";
/// let this_library_node_name2 = "411902.CLOBOL_07349";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_bolteae_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_bolteae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_bolteae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_bolteae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["411902"]),
        None,
        Some("."),
        Some("CLOBOL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia duttonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "412419.BDU_1";
/// let this_library_node_name2 = "412419.BDU_99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_duttonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_duttonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_duttonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_duttonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["412419"]),
        None,
        Some("."),
        Some("BDU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus sp. TRP nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "412597.AEPN01000001_gene2899";
/// let this_library_node_name2 = "412597.AEPN01000119_gene1256";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_sp_trp_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_sp_trp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_sp_trp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_sp_trp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["412597"]),
        None,
        Some("."),
        Some("AEPN01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vesicomyosocius okutanii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "412965.COSY_0001";
/// let this_library_node_name2 = "412965.COSY_0978";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vesicomyosocius_okutanii_node_name(this_library_node_name1));
/// assert!(is_valid_string_vesicomyosocius_okutanii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vesicomyosocius_okutanii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vesicomyosocius_okutanii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["412965"]),
        None,
        Some("."),
        Some("COSY_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruthia magnifica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "413404.Rmag_0001";
/// let this_library_node_name2 = "413404.Rmag_1076";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruthia_magnifica_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruthia_magnifica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruthia_magnifica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruthia_magnifica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["413404"]),
        None,
        Some("."),
        Some("Rmag_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halorubrum halophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "413816.BBJP01000001_gene1";
/// let this_library_node_name2 = "413816.BBJP01000101_gene3094";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halorubrum_halophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_halorubrum_halophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halorubrum_halophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halorubrum_halophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["413816"]),
        None,
        Some("."),
        Some("BBJP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodospirillum centenum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "414684.RC1_0011";
/// let this_library_node_name2 = "414684.RC1_4128";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodospirillum_centenum_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodospirillum_centenum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodospirillum_centenum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodospirillum_centenum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["414684"]),
        None,
        Some("."),
        Some("RC1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinopolyspora erythraea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "414996.IL38_00005";
/// let this_library_node_name2 = "414996.IL38_24575";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinopolyspora_erythraea_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinopolyspora_erythraea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinopolyspora_erythraea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinopolyspora_erythraea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["414996"]),
        None,
        Some("."),
        Some("IL38_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyperthermus butylicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "415426.Hbut_0001";
/// let this_library_node_name2 = "415426.Hbut_1670";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyperthermus_butylicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyperthermus_butylicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyperthermus_butylicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyperthermus_butylicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["415426"]),
        None,
        Some("."),
        Some("Hbut_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobacillus pleuropneumoniae 5b L20 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "416269.APL_0001";
/// let this_library_node_name2 = "416269.APL_2046";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobacillus_pleuropneumoniae_5b_l20_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobacillus_pleuropneumoniae_5b_l20_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobacillus_pleuropneumoniae_5b_l20_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobacillus_pleuropneumoniae_5b_l20_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["416269"]),
        None,
        Some("."),
        Some("APL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halorubrum lacusprofundi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "416348.Hlac_0001";
/// let this_library_node_name2 = "416348.Hlac_3666";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halorubrum_lacusprofundi_node_name(this_library_node_name1));
/// assert!(is_valid_string_halorubrum_lacusprofundi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halorubrum_lacusprofundi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halorubrum_lacusprofundi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["416348"]),
        None,
        Some("."),
        Some("Hlac_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermotoga lettingae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "416591.Tlet_0001";
/// let this_library_node_name2 = "416591.Tlet_2059";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermotoga_lettingae_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermotoga_lettingae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermotoga_lettingae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermotoga_lettingae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["416591"]),
        None,
        Some("."),
        Some("Tlet_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactococcus lactis cremoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "416870.124492997";
/// let this_library_node_name2 = "416870.llmg_2563";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactococcus_lactis_cremoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactococcus_lactis_cremoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactococcus_lactis_cremoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactococcus_lactis_cremoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["416870"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium extorquens PA1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "419610.Mext_0001";
/// let this_library_node_name2 = "419610.Mext_4890";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_extorquens_pa1_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_extorquens_pa1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_extorquens_pa1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_extorquens_pa1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["419610"]),
        None,
        Some("."),
        Some("Mext_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanococcus aeolicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "419665.Maeo_0001";
/// let this_library_node_name2 = "419665.Maeo_1507";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanococcus_aeolicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanococcus_aeolicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanococcus_aeolicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanococcus_aeolicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["419665"]),
        None,
        Some("."),
        Some("Maeo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium tuberculosis H37Ra nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "419947.MRA_0001";
/// let this_library_node_name2 = "419947.MRA_3963";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_tuberculosis_h37ra_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_tuberculosis_h37ra_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_tuberculosis_h37ra_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_tuberculosis_h37ra_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["419947"]),
        None,
        Some("."),
        Some("MRA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacillus thermodenitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "420246.GTNG_0001";
/// let this_library_node_name2 = "420246.GTNG_3499";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacillus_thermodenitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacillus_thermodenitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacillus_thermodenitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacillus_thermodenitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["420246"]),
        None,
        Some("."),
        Some("GTNG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanobrevibacter smithii ATCC35061 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "420247.Msm_0001";
/// let this_library_node_name2 = "420247.Msm_1795";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanobrevibacter_smithii_atcc35061_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanobrevibacter_smithii_atcc35061_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanobrevibacter_smithii_atcc35061_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanobrevibacter_smithii_atcc35061_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["420247"]),
        None,
        Some("."),
        Some("Msm_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microvirga lupini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "420324.KI911932_gene321";
/// let this_library_node_name2 = "420324.KI912090_gene7202";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microvirga_lupini_node_name(this_library_node_name1));
/// assert!(is_valid_string_microvirga_lupini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microvirga_lupini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microvirga_lupini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["420324"]),
        None,
        Some("."),
        Some("KI91"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylibium petroleiphilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "420662.Mpe_A0001";
/// let this_library_node_name2 = "420662.Mpe_B0648";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylibium_petroleiphilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylibium_petroleiphilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylibium_petroleiphilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylibium_petroleiphilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["420662"]),
        None,
        Some("."),
        Some("Mpe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactococcus garvieae Lg2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "420890.LCGL_0001";
/// let this_library_node_name2 = "420890.LCGL_1968";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactococcus_garvieae_lg2_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactococcus_garvieae_lg2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactococcus_garvieae_lg2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactococcus_garvieae_lg2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["420890"]),
        None,
        Some("."),
        Some("LCGL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter rudis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "421052.F945_00001";
/// let this_library_node_name2 = "421052.F945_03706";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_rudis_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_rudis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_rudis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_rudis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["421052"]),
        None,
        Some("."),
        Some("F945_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Epilithonimonas lactis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "421072.IO89_00005";
/// let this_library_node_name2 = "421072.IO89_20575";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_epilithonimonas_lactis_node_name(this_library_node_name1));
/// assert!(is_valid_string_epilithonimonas_lactis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_epilithonimonas_lactis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_epilithonimonas_lactis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["421072"]),
        None,
        Some("."),
        Some("IO89_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium luteum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "421531.IX38_00015";
/// let this_library_node_name2 = "421531.IX38_22925";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_luteum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_luteum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_luteum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_luteum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["421531"]),
        None,
        Some("."),
        Some("IX38_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella sediminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "425104.Ssed_0001";
/// let this_library_node_name2 = "425104.Ssed_4508";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_sediminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_sediminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_sediminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_sediminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["425104"]),
        None,
        Some("."),
        Some("Ssed_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter sp. MIT016451 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "425400.LS65_00010";
/// let this_library_node_name2 = "425400.LS65_10785";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_sp_mit016451_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_sp_mit016451_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_sp_mit016451_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_sp_mit016451_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["425400"]),
        None,
        Some("."),
        Some("LS65_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiomonas arsenitoxydans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "426114.THI_0001";
/// let this_library_node_name2 = "426114.THI_CDS708816D";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiomonas_arsenitoxydans_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiomonas_arsenitoxydans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiomonas_arsenitoxydans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiomonas_arsenitoxydans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["426114"]),
        None,
        Some("."),
        Some("THI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium sp. 446 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "426117.M446_0001";
/// let this_library_node_name2 = "426117.M446_7041";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_sp_446_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_sp_446_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_sp_446_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_sp_446_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["426117"]),
        None,
        Some("."),
        Some("M446_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium radiotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "426355.Mrad2831_0001";
/// let this_library_node_name2 = "426355.Mrad2831_6298";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_radiotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_radiotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_radiotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_radiotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["426355"]),
        None,
        Some("."),
        Some("Mrad2831_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanococcus maripaludis C7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "426368.MmarC7_0001";
/// let this_library_node_name2 = "426368.MmarC7_1808";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanococcus_maripaludis_c7_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanococcus_maripaludis_c7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanococcus_maripaludis_c7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanococcus_maripaludis_c7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["426368"]),
        None,
        Some("."),
        Some("MmarC7_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia rhamnosiphila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "426716.JOAJ01000001_gene100";
/// let this_library_node_name2 = "426716.JOAJ01000093_gene6524";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_rhamnosiphila_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_rhamnosiphila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_rhamnosiphila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_rhamnosiphila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["426716"]),
        None,
        Some("."),
        Some("JOAJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium leptum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "428125.CLOLEP_00001";
/// let this_library_node_name2 = "428125.CLOLEP_03979";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_leptum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_leptum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_leptum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_leptum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["428125"]),
        None,
        Some("."),
        Some("CLOLEP_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium spiroforme nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "428126.CLOSPI_00001";
/// let this_library_node_name2 = "428126.CLOSPI_02533";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_spiroforme_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_spiroforme_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_spiroforme_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_spiroforme_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["428126"]),
        None,
        Some("."),
        Some("CLOSPI_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium dolichum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "428127.EUBDOL_00001";
/// let this_library_node_name2 = "428127.EUBDOL_02395";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_dolichum_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_dolichum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_dolichum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_dolichum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["428127"]),
        None,
        Some("."),
        Some("EUBDOL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ammonifex degensii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "429009.Adeg_0001";
/// let this_library_node_name2 = "429009.Adeg_2181";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ammonifex_degensii_node_name(this_library_node_name1));
/// assert!(is_valid_string_ammonifex_degensii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ammonifex_degensii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ammonifex_degensii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["429009"]),
        None,
        Some("."),
        Some("Adeg_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dactylellina haptotyla nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "430498.S7ZWC1";
/// let this_library_node_name2 = "430498.S8CEA9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dactylellina_haptotyla_node_name(this_library_node_name1));
/// assert!(is_valid_string_dactylellina_haptotyla_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dactylellina_haptotyla_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dactylellina_haptotyla_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["430498"]),
        None,
        Some("."),
        Some("S"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Baudoinia compniacensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "430998.XP_007671535.1";
/// let this_library_node_name2 = "430998.XP_007682042.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_baudoinia_compniacensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_baudoinia_compniacensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_baudoinia_compniacensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_baudoinia_compniacensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["430998"]),
        None,
        Some("."),
        Some("XP_0076"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium kluyveri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "431943.CKL_0001";
/// let this_library_node_name2 = "431943.CKL_4074";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_kluyveri_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_kluyveri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_kluyveri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_kluyveri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["431943"]),
        None,
        Some("."),
        Some("CKL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas gingivalis ATCC33277 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "431947.PGN_0001";
/// let this_library_node_name2 = "431947.PGN_2091";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_gingivalis_atcc33277_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_gingivalis_atcc33277_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_gingivalis_atcc33277_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_gingivalis_atcc33277_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["431947"]),
        None,
        Some("."),
        Some("PGN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kazachstania africana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "432096.XP_003954583.1";
/// let this_library_node_name2 = "432096.XP_003959960.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kazachstania_africana_node_name(this_library_node_name1));
/// assert!(is_valid_string_kazachstania_africana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kazachstania_africana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kazachstania_africana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["432096"]),
        None,
        Some("."),
        Some("XP_00395"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neorickettsia risticii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "434131.NRI_0001";
/// let this_library_node_name2 = "434131.NRI_0932";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neorickettsia_risticii_node_name(this_library_node_name1));
/// assert!(is_valid_string_neorickettsia_risticii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neorickettsia_risticii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neorickettsia_risticii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["434131"]),
        None,
        Some("."),
        Some("NRI_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides vulgatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "435590.BVU_0001";
/// let this_library_node_name2 = "435590.BVU_4194";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_vulgatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_vulgatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_vulgatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_vulgatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["435590"]),
        None,
        Some("."),
        Some("BVU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parabacteroides distasonis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "435591.BDI_0001";
/// let this_library_node_name2 = "435591.BDI_3971";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parabacteroides_distasonis_node_name(this_library_node_name1));
/// assert!(is_valid_string_parabacteroides_distasonis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parabacteroides_distasonis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parabacteroides_distasonis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["435591"]),
        None,
        Some("."),
        Some("BDI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces graevenitzii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "435830.HMPREF0045_00001";
/// let this_library_node_name2 = "435830.HMPREF0045_01853";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_graevenitzii_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_graevenitzii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_graevenitzii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_graevenitzii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["435830"]),
        None,
        Some("."),
        Some("HMPREF0045_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria mucosa C102 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "435832.HMPREF0604_00001";
/// let this_library_node_name2 = "435832.HMPREF0604_02027";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_mucosa_c102_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_mucosa_c102_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_mucosa_c102_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_mucosa_c102_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["435832"]),
        None,
        Some("."),
        Some("HMPREF0604_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus hominis C80 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "435837.HMPREF0798_00001";
/// let this_library_node_name2 = "435837.HMPREF0798_02188";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_hominis_c80_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_hominis_c80_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_hominis_c80_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_hominis_c80_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["435837"]),
        None,
        Some("."),
        Some("HMPREF0798_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus capitis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "435838.HMPREF0786_00001";
/// let this_library_node_name2 = "435838.HMPREF0786_02421";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_capitis_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_capitis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_capitis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_capitis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["435838"]),
        None,
        Some("."),
        Some("HMPREF0786_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. C150 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "435842.HMPREF0848_00001";
/// let this_library_node_name2 = "435842.HMPREF0848_01978";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_c150_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_c150_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_c150_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_c150_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["435842"]),
        None,
        Some("."),
        Some("HMPREF0848_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Idiomarina salinarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "435908.IDSA_00005";
/// let this_library_node_name2 = "435908.IDSA_11890";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_idiomarina_salinarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_idiomarina_salinarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_idiomarina_salinarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_idiomarina_salinarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["435908"]),
        None,
        Some("."),
        Some("IDSA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurihydrogenibium sp. YO3AOP1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "436114.SYO3AOP1_0001";
/// let this_library_node_name2 = "436114.SYO3AOP1_1778";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurihydrogenibium_sp_yo3aop1_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurihydrogenibium_sp_yo3aop1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurihydrogenibium_sp_yo3aop1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurihydrogenibium_sp_yo3aop1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["436114"]),
        None,
        Some("."),
        Some("SYO3AOP1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptacidiphilus jeojiense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "436229.JOEH01000001_gene1278";
/// let this_library_node_name2 = "436229.JOEH01000143_gene7354";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptacidiphilus_jeojiense_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptacidiphilus_jeojiense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptacidiphilus_jeojiense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptacidiphilus_jeojiense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["436229"]),
        None,
        Some("."),
        Some("JOEH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosopumilus maritimus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "436308.Nmar_0001";
/// let this_library_node_name2 = "436308.Nmar_1799";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosopumilus_maritimus_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosopumilus_maritimus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosopumilus_maritimus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosopumilus_maritimus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["436308"]),
        None,
        Some("."),
        Some("Nmar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter oleivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "436717.AOLE_00005";
/// let this_library_node_name2 = "436717.AOLE_19475";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_oleivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_oleivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_oleivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_oleivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["436717"]),
        None,
        Some("."),
        Some("AOLE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Azorhizobium caulinodans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "438753.AZC_0001";
/// let this_library_node_name2 = "438753.AZC_4717";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_azorhizobium_caulinodans_node_name(this_library_node_name1));
/// assert!(is_valid_string_azorhizobium_caulinodans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_azorhizobium_caulinodans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_azorhizobium_caulinodans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["438753"]),
        None,
        Some("."),
        Some("AZC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfatibacillum alkenivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "439235.Dalk_0001";
/// let this_library_node_name2 = "439235.Dalk_R0062";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfatibacillum_alkenivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfatibacillum_alkenivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfatibacillum_alkenivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfatibacillum_alkenivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["439235"]),
        None,
        Some("."),
        Some("Dalk_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus selenitireducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "439292.Bsel_0001";
/// let this_library_node_name2 = "439292.Bsel_3326";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_selenitireducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_selenitireducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_selenitireducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_selenitireducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["439292"]),
        None,
        Some("."),
        Some("Bsel_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ochrobactrum anthropi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "439375.Oant_0002";
/// let this_library_node_name2 = "439375.Oant_4860";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ochrobactrum_anthropi_node_name(this_library_node_name1));
/// assert!(is_valid_string_ochrobactrum_anthropi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ochrobactrum_anthropi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ochrobactrum_anthropi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["439375"]),
        None,
        Some("."),
        Some("Oant_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aciduliprofundum boonei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "439481.Aboo_0001";
/// let this_library_node_name2 = "439481.Aboo_1550";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aciduliprofundum_boonei_node_name(this_library_node_name1));
/// assert!(is_valid_string_aciduliprofundum_boonei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aciduliprofundum_boonei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aciduliprofundum_boonei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["439481"]),
        None,
        Some("."),
        Some("Aboo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibacter sp. HTCC7211 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "439493.PB7211_1";
/// let this_library_node_name2 = "439493.PB7211_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibacter_sp_htcc7211_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibacter_sp_htcc7211_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibacter_sp_htcc7211_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibacter_sp_htcc7211_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["439493"]),
        None,
        Some("."),
        Some("PB7211_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodobacterales bacterium Y4I nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "439496.RBY4I_1";
/// let this_library_node_name2 = "439496.RBY4I_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodobacterales_bacterium_y4i_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodobacterales_bacterium_y4i_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodobacterales_bacterium_y4i_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodobacterales_bacterium_y4i_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["439496"]),
        None,
        Some("."),
        Some("RBY4I_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruegeria sp. R11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "439497.RR11_1";
/// let this_library_node_name2 = "439497.RR11_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruegeria_sp_r11_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruegeria_sp_r11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruegeria_sp_r11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruegeria_sp_r11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["439497"]),
        None,
        Some("."),
        Some("RR11_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. Chol1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "440512.C211_00005";
/// let this_library_node_name2 = "440512.C211_23395";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_chol1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_chol1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_chol1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_chol1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["440512"]),
        None,
        Some("."),
        Some("C211_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium populi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "441620.Mpop_0001";
/// let this_library_node_name2 = "441620.Mpop_5472";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_populi_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_populi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_populi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_populi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["441620"]),
        None,
        Some("."),
        Some("Mpop_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acholeplasma laidlawii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "441768.ACL_0001";
/// let this_library_node_name2 = "441768.ACL_1433";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acholeplasma_laidlawii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acholeplasma_laidlawii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acholeplasma_laidlawii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acholeplasma_laidlawii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["441768"]),
        None,
        Some("."),
        Some("ACL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus coahuilensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "441769.ABFU01000001_gene3050";
/// let this_library_node_name2 = "441769.ABFU01000138_gene3468";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_coahuilensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_coahuilensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_coahuilensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_coahuilensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["441769"]),
        None,
        Some("."),
        Some("ABFU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacter sp. M18 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "443143.GM18_0001";
/// let this_library_node_name2 = "443143.GM18_4524";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacter_sp_m18_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacter_sp_m18_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacter_sp_m18_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacter_sp_m18_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["443143"]),
        None,
        Some("."),
        Some("GM18_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacter sp. M21 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "443144.GM21_0001";
/// let this_library_node_name2 = "443144.GM21_4152";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacter_sp_m21_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacter_sp_m21_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacter_sp_m21_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacter_sp_m21_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["443144"]),
        None,
        Some("."),
        Some("GM21_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter algicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "443152.MDG893_00005";
/// let this_library_node_name2 = "443152.MDG893_20739";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_algicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_algicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_algicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_algicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["443152"]),
        None,
        Some("."),
        Some("MDG893_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolicicoccus subflavus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "443218.AS9A_0001";
/// let this_library_node_name2 = "443218.AS9A_P10027";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolicicoccus_subflavus_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolicicoccus_subflavus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolicicoccus_subflavus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolicicoccus_subflavus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["443218"]),
        None,
        Some("."),
        Some("AS9A_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinitoga piezophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "443254.Marpi_0001";
/// let this_library_node_name2 = "443254.Marpi_2133";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinitoga_piezophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinitoga_piezophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinitoga_piezophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinitoga_piezophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["443254"]),
        None,
        Some("."),
        Some("Marpi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces clavuligerus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "443255.SCLAV_0001";
/// let this_library_node_name2 = "443255.SCLAV_p1595";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_clavuligerus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_clavuligerus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_clavuligerus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_clavuligerus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["443255"]),
        None,
        Some("."),
        Some("SCLAV_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. Cp53 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "443598.AUFA01000001_gene1000";
/// let this_library_node_name2 = "443598.AUFA01000150_gene6338";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_cp53_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_cp53_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_cp53_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_cp53_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["443598"]),
        None,
        Some("."),
        Some("AUFA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clavibacter michiganensis NCPPB382 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "443906.CMM_0001";
/// let this_library_node_name2 = "443906.pCM1_0028";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clavibacter_michiganensis_ncppb382_node_name(this_library_node_name1));
/// assert!(is_valid_string_clavibacter_michiganensis_ncppb382_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clavibacter_michiganensis_ncppb382_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clavibacter_michiganensis_ncppb382_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["443906"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrobaculum neutrophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "444157.Tneu_0001";
/// let this_library_node_name2 = "444157.Tneu_2010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrobaculum_neutrophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrobaculum_neutrophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrobaculum_neutrophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrobaculum_neutrophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["444157"]),
        None,
        Some("."),
        Some("Tneu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanococcus maripaludis C6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "444158.MmarC6_0001";
/// let this_library_node_name2 = "444158.MmarC6_1842";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanococcus_maripaludis_c6_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanococcus_maripaludis_c6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanococcus_maripaludis_c6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanococcus_maripaludis_c6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["444158"]),
        None,
        Some("."),
        Some("MmarC6_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium botulinum NCTC2916 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "445335.CBN_0001";
/// let this_library_node_name2 = "445335.CBN_A0063";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_botulinum_nctc2916_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_botulinum_nctc2916_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_botulinum_nctc2916_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_botulinum_nctc2916_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["445335"]),
        None,
        Some("."),
        Some("CBN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium soli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "445961.IW15_00005";
/// let this_library_node_name2 = "445961.IW15_22765";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_soli_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_soli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_soli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_soli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["445961"]),
        None,
        Some("."),
        Some("IW15_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alistipes putredinis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "445970.ALIPUT_00001";
/// let this_library_node_name2 = "445970.ALIPUT_02798";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alistipes_putredinis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alistipes_putredinis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alistipes_putredinis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alistipes_putredinis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["445970"]),
        None,
        Some("."),
        Some("ALIPUT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerofustis stercorihominis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "445971.ANASTE_00001";
/// let this_library_node_name2 = "445971.ANASTE_02382";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerofustis_stercorihominis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerofustis_stercorihominis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerofustis_stercorihominis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerofustis_stercorihominis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["445971"]),
        None,
        Some("."),
        Some("ANASTE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerotruncus colihominis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "445972.ANACOL_00001";
/// let this_library_node_name2 = "445972.ANACOL_04500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerotruncus_colihominis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerotruncus_colihominis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerotruncus_colihominis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerotruncus_colihominis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["445972"]),
        None,
        Some("."),
        Some("ANACOL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Intestinibacter bartlettii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "445973.CLOBAR_00001";
/// let this_library_node_name2 = "445973.CLOBAR_02871";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_intestinibacter_bartlettii_node_name(this_library_node_name1));
/// assert!(is_valid_string_intestinibacter_bartlettii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_intestinibacter_bartlettii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_intestinibacter_bartlettii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["445973"]),
        None,
        Some("."),
        Some("CLOBAR_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erysipelatoclostridium ramosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "445974.CLORAM_00001";
/// let this_library_node_name2 = "445974.CLORAM_03221";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erysipelatoclostridium_ramosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_erysipelatoclostridium_ramosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erysipelatoclostridium_ramosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erysipelatoclostridium_ramosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["445974"]),
        None,
        Some("."),
        Some("CLORAM_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Collinsella stercoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "445975.COLSTE_00001";
/// let this_library_node_name2 = "445975.COLSTE_02585";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_collinsella_stercoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_collinsella_stercoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_collinsella_stercoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_collinsella_stercoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["445975"]),
        None,
        Some("."),
        Some("COLSTE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia valaisiana VS116 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "445987.BVAVS116_0001";
/// let this_library_node_name2 = "445987.BVAVS116_B0028";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_valaisiana_vs116_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_valaisiana_vs116_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_valaisiana_vs116_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_valaisiana_vs116_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["445987"]),
        None,
        Some("."),
        Some("BVAVS116_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinosynnema mirum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "446462.Amir_0001";
/// let this_library_node_name2 = "446462.Amir_7100";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinosynnema_mirum_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinosynnema_mirum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinosynnema_mirum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinosynnema_mirum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["446462"]),
        None,
        Some("."),
        Some("Amir_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachybacterium faecium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "446465.Bfae_00010";
/// let this_library_node_name2 = "446465.Bfae_31980";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachybacterium_faecium_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachybacterium_faecium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachybacterium_faecium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachybacterium_faecium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["446465"]),
        None,
        Some("."),
        Some("Bfae_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellulomonas flavigena nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "446466.Cfla_0001";
/// let this_library_node_name2 = "446466.Cfla_3730";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellulomonas_flavigena_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellulomonas_flavigena_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellulomonas_flavigena_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellulomonas_flavigena_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["446466"]),
        None,
        Some("."),
        Some("Cfla_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardiopsis dassonvillei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "446468.Ndas_0001";
/// let this_library_node_name2 = "446468.Ndas_R0045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardiopsis_dassonvillei_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardiopsis_dassonvillei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardiopsis_dassonvillei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardiopsis_dassonvillei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["446468"]),
        None,
        Some("."),
        Some("Ndas_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sanguibacter keddieii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "446469.Sked_00010";
/// let this_library_node_name2 = "446469.Sked_38060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sanguibacter_keddieii_node_name(this_library_node_name1));
/// assert!(is_valid_string_sanguibacter_keddieii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sanguibacter_keddieii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sanguibacter_keddieii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["446469"]),
        None,
        Some("."),
        Some("Sked_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stackebrandtia nassauensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "446470.Snas_0001";
/// let this_library_node_name2 = "446470.Snas_6487";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stackebrandtia_nassauensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_stackebrandtia_nassauensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stackebrandtia_nassauensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stackebrandtia_nassauensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["446470"]),
        None,
        Some("."),
        Some("Snas_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xylanimonas cellulosilytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "446471.Xcel_0001";
/// let this_library_node_name2 = "446471.Xcel_3485";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xylanimonas_cellulosilytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_xylanimonas_cellulosilytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xylanimonas_cellulosilytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xylanimonas_cellulosilytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["446471"]),
        None,
        Some("."),
        Some("Xcel_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sorangium cellulosum So ce56 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "448385.missed_out";
/// let this_library_node_name2 = "448385.sce_pseudo_16";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sorangium_cellulosum_so_ce56_node_name(this_library_node_name1));
/// assert!(is_valid_string_sorangium_cellulosum_so_ce56_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sorangium_cellulosum_so_ce56_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sorangium_cellulosum_so_ce56_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["448385"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microcystis aeruginosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "449447.MAE_00010";
/// let this_library_node_name2 = "449447.MAE_63120";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microcystis_aeruginosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_microcystis_aeruginosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microcystis_aeruginosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microcystis_aeruginosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["449447"]),
        None,
        Some("."),
        Some("MAE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides stercoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "449673.BACSTE_00001";
/// let this_library_node_name2 = "449673.BACSTE_03848";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_stercoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_stercoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_stercoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_stercoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["449673"]),
        None,
        Some("."),
        Some("BACSTE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium profundi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "450380.JPSY01000001_gene1";
/// let this_library_node_name2 = "450380.JPSY01000012_gene3148";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_profundi_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_profundi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_profundi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_profundi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["450380"]),
        None,
        Some("."),
        Some("JPSY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phenylobacterium zucineum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "450851.PHZ_c0001";
/// let this_library_node_name2 = "450851.PHZ_p0327";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phenylobacterium_zucineum_node_name(this_library_node_name1));
/// assert!(is_valid_string_phenylobacterium_zucineum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phenylobacterium_zucineum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phenylobacterium_zucineum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["450851"]),
        None,
        Some("."),
        Some("PHZ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amoebophilus asiaticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "452471.Aasi_0001";
/// let this_library_node_name2 = "452471.Aasi_1962";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amoebophilus_asiaticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_amoebophilus_asiaticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amoebophilus_asiaticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amoebophilus_asiaticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["452471"]),
        None,
        Some("."),
        Some("Aasi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Opitutus terrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "452637.Oter_0001";
/// let this_library_node_name2 = "452637.Oter_4634";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_opitutus_terrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_opitutus_terrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_opitutus_terrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_opitutus_terrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["452637"]),
        None,
        Some("."),
        Some("Oter_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polynucleobacter necessarius STIR1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "452638.Pnec_0001";
/// let this_library_node_name2 = "452638.Pnec_1787";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polynucleobacter_necessarius_stir1_node_name(this_library_node_name1));
/// assert!(is_valid_string_polynucleobacter_necessarius_stir1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polynucleobacter_necessarius_stir1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polynucleobacter_necessarius_stir1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["452638"]),
        None,
        Some("."),
        Some("Pnec_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kitasatospora setae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "452652.KSE_00010t";
/// let this_library_node_name2 = "452652.KSE_76730t";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kitasatospora_setae_node_name(this_library_node_name1));
/// assert!(is_valid_string_kitasatospora_setae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kitasatospora_setae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kitasatospora_setae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["452652"]),
        None,
        Some("."),
        Some("KSE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia rickettsii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "452659.RrIowa_0001";
/// let this_library_node_name2 = "452659.RrIowa_1604";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_rickettsii_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_rickettsii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_rickettsii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_rickettsii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["452659"]),
        None,
        Some("."),
        Some("RrIowa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium japonicum UT26S nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "452662.SJA_C1-00010";
/// let this_library_node_name2 = "452662.SJA_P3-00080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_japonicum_ut26s_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_japonicum_ut26s_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_japonicum_ut26s_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_japonicum_ut26s_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["452662"]),
        None,
        Some("."),
        Some("SJA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter chlorophenolicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "452863.Achl_0001";
/// let this_library_node_name2 = "452863.Achl_4642";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_chlorophenolicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_chlorophenolicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_chlorophenolicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_chlorophenolicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["452863"]),
        None,
        Some("."),
        Some("Achl_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ignicoccus hospitalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "453591.Igni_0001";
/// let this_library_node_name2 = "453591.Igni_1442";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ignicoccus_hospitalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ignicoccus_hospitalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ignicoccus_hospitalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ignicoccus_hospitalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["453591"]),
        None,
        Some("."),
        Some("Igni_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas arboricola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "454957.IA64_00005";
/// let this_library_node_name2 = "454957.IA64_21120";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_arboricola_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_arboricola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_arboricola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_arboricola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["454957"]),
        None,
        Some("."),
        Some("IA64_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glaciecola sp. HTCC2999 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "455436.DS989810_gene1";
/// let this_library_node_name2 = "455436.DS989817_gene2040";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glaciecola_sp_htcc2999_node_name(this_library_node_name1));
/// assert!(is_valid_string_glaciecola_sp_htcc2999_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glaciecola_sp_htcc2999_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glaciecola_sp_htcc2999_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["455436"]),
        None,
        Some("."),
        Some("DS98981"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces griseus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "455632.SGR_1000";
/// let this_library_node_name2 = "455632.SGR_9t";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_griseus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_griseus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_griseus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_griseus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["455632"]),
        None,
        Some("."),
        Some("SGR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanococcus voltae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "456320.Mvol_0001";
/// let this_library_node_name2 = "456320.Mvol_1722";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanococcus_voltae_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanococcus_voltae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanococcus_voltae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanococcus_voltae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["456320"]),
        None,
        Some("."),
        Some("Mvol_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanoregula boonei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "456442.Mboo_0001";
/// let this_library_node_name2 = "456442.Mboo_2460";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanoregula_boonei_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanoregula_boonei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanoregula_boonei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanoregula_boonei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["456442"]),
        None,
        Some("."),
        Some("Mboo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. 7243FAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "457396.CSBG_00001";
/// let this_library_node_name2 = "457396.CSBG_03570";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_7243faa_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_7243faa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_7243faa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_7243faa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["457396"]),
        None,
        Some("."),
        Some("CSBG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio sp. 31syn3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "457398.HMPREF0326_00002";
/// let this_library_node_name2 = "457398.HMPREF0326_05814";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_sp_31syn3_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_sp_31syn3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_sp_31syn3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_sp_31syn3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["457398"]),
        None,
        Some("."),
        Some("HMPREF0326_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium nucleatum animalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "457405.FSDG_00001";
/// let this_library_node_name2 = "457405.FSDG_03007";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_nucleatum_animalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_nucleatum_animalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_nucleatum_animalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_nucleatum_animalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["457405"]),
        None,
        Some("."),
        Some("FSDG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus sp. 5139BFAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "457412.RSAG_00002";
/// let this_library_node_name2 = "457412.RSAG_04775";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_sp_5139bfaa_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_sp_5139bfaa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_sp_5139bfaa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_sp_5139bfaa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["457412"]),
        None,
        Some("."),
        Some("RSAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synergistes sp. 31syn1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "457415.HMPREF1006_00001";
/// let this_library_node_name2 = "457415.HMPREF1006_02960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synergistes_sp_31syn1_node_name(this_library_node_name1));
/// assert!(is_valid_string_synergistes_sp_31syn1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synergistes_sp_31syn1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synergistes_sp_31syn1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["457415"]),
        None,
        Some("."),
        Some("HMPREF1006_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium 1747FAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "457421.CBFG_00001";
/// let this_library_node_name2 = "457421.CBFG_06255";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_1747faa_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_1747faa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_1747faa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_1747faa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["457421"]),
        None,
        Some("."),
        Some("CBFG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides fragilis 3112 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "457424.BFAG_00001";
/// let this_library_node_name2 = "457424.BFAG_06503";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_fragilis_3112_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_fragilis_3112_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_fragilis_3112_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_fragilis_3112_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["457424"]),
        None,
        Some("."),
        Some("BFAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces albus J1074 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "457425.XNR_0001";
/// let this_library_node_name2 = "457425.XNR_5937";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_albus_j1074_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_albus_j1074_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_albus_j1074_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_albus_j1074_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["457425"]),
        None,
        Some("."),
        Some("XNR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces pristinaespiralis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "457429.ABJI02000001_gene4684";
/// let this_library_node_name2 = "457429.ABJI02000844_gene3291";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_pristinaespiralis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_pristinaespiralis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_pristinaespiralis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_pristinaespiralis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["457429"]),
        None,
        Some("."),
        Some("ABJI02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natranaerobius thermophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "457570.Nther_0001";
/// let this_library_node_name2 = "457570.Nther_2960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natranaerobius_thermophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_natranaerobius_thermophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natranaerobius_thermophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natranaerobius_thermophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["457570"]),
        None,
        Some("."),
        Some("Nther_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Macrococcus caseolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "458233.MCCL_0001";
/// let this_library_node_name2 = "458233.MCCL_plsA0014";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_macrococcus_caseolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_macrococcus_caseolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_macrococcus_caseolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_macrococcus_caseolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["458233"]),
        None,
        Some("."),
        Some("MCCL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella halifaxensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "458817.Shal_0001";
/// let this_library_node_name2 = "458817.Shal_4314";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_halifaxensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_halifaxensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_halifaxensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_halifaxensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["458817"]),
        None,
        Some("."),
        Some("Shal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cloacimonas acidaminovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "459349.CLOAM0001";
/// let this_library_node_name2 = "459349.CLOAM1908";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cloacimonas_acidaminovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_cloacimonas_acidaminovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cloacimonas_acidaminovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cloacimonas_acidaminovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["459349"]),
        None,
        Some("."),
        Some("CLOAM"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrospira platensis C1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "459495.SPLC1_S010010";
/// let this_library_node_name2 = "459495.SPLC1_S630390";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrospira_platensis_c1_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrospira_platensis_c1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrospira_platensis_c1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrospira_platensis_c1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["459495"]),
        None,
        Some("."),
        Some("SPLC1_S"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium nodulans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "460265.Mnod_0001";
/// let this_library_node_name2 = "460265.Mnod_8817";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_nodulans_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_nodulans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_nodulans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_nodulans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["460265"]),
        None,
        Some("."),
        Some("Mnod_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sviceus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "463191.SSEG_00001";
/// let this_library_node_name2 = "463191.SSEG_11378";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sviceus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sviceus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sviceus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sviceus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["463191"]),
        None,
        Some("."),
        Some("SSEG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Micrococcus luteus NCTC 2665 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "465515.Mlut_00010";
/// let this_library_node_name2 = "465515.Mlut_23480";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_micrococcus_luteus_nctc_2665_node_name(this_library_node_name1));
/// assert!(is_valid_string_micrococcus_luteus_nctc_2665_node_name(this_library_node_name2));
/// assert!(!is_valid_string_micrococcus_luteus_nctc_2665_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_micrococcus_luteus_nctc_2665_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["465515"]),
        None,
        Some("."),
        Some("Mlut_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. Mg1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "465541.ATCJ01000001_gene135";
/// let this_library_node_name2 = "465541.ATCJ01000007_gene7733";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_mg1_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_mg1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_mg1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_mg1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["465541"]),
        None,
        Some("."),
        Some("ATCJ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erwinia tasmaniensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "465817.ETA_00010";
/// let this_library_node_name2 = "465817.ETA_pET350420";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erwinia_tasmaniensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_erwinia_tasmaniensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erwinia_tasmaniensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erwinia_tasmaniensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["465817"]),
        None,
        Some("."),
        Some("ETA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibacter ubique HTCC8051 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "466038.KI421440_gene1";
/// let this_library_node_name2 = "466038.KI421440_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibacter_ubique_htcc8051_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibacter_ubique_htcc8051_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibacter_ubique_htcc8051_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibacter_ubique_htcc8051_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["466038"]),
        None,
        Some("."),
        Some("KI421440_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. Ver3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "466088.CL42_00005";
/// let this_library_node_name2 = "466088.CL42_16910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_ver3_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_ver3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_ver3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_ver3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["466088"]),
        None,
        Some("."),
        Some("CL42_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces griseoflavus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "467200.ACFA01000001_gene1839";
/// let this_library_node_name2 = "467200.ACFA01000927_gene6398";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_griseoflavus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_griseoflavus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_griseoflavus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_griseoflavus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["467200"]),
        None,
        Some("."),
        Some("ACFA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodobacteraceae bacterium KLH11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "467661.RKLH11_1";
/// let this_library_node_name2 = "467661.RKLH11_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodobacteraceae_bacterium_klh11_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodobacteraceae_bacterium_klh11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodobacteraceae_bacterium_klh11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodobacteraceae_bacterium_klh11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["467661"]),
        None,
        Some("."),
        Some("RKLH11_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus gordonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "467705.SGO_0001";
/// let this_library_node_name2 = "467705.SGO_2151";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_gordonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_gordonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_gordonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_gordonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["467705"]),
        None,
        Some("."),
        Some("SGO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pedobacter oryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "468059.AUHA01000001_gene2629";
/// let this_library_node_name2 = "468059.AUHA01000011_gene2836";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pedobacter_oryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_pedobacter_oryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pedobacter_oryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pedobacter_oryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["468059"]),
        None,
        Some("."),
        Some("AUHA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia kroppenstedtii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "468556.AQYG01000004_gene2777";
/// let this_library_node_name2 = "468556.AQYG01000051_gene2691";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_kroppenstedtii_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_kroppenstedtii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_kroppenstedtii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_kroppenstedtii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["468556"]),
        None,
        Some("."),
        Some("AQYG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia coli BL21 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469008.B21_00001";
/// let this_library_node_name2 = "469008.B21_04549";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_coli_bl21_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_coli_bl21_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_coli_bl21_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_coli_bl21_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469008"]),
        None,
        Some("."),
        Some("B21_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermobispora bispora nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469371.Tbis_0001";
/// let this_library_node_name2 = "469371.Tbis_3596";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermobispora_bispora_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermobispora_bispora_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermobispora_bispora_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermobispora_bispora_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469371"]),
        None,
        Some("."),
        Some("Tbis_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cryptobacterium curtum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469378.Ccur_00010";
/// let this_library_node_name2 = "469378.Ccur_14220";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cryptobacterium_curtum_node_name(this_library_node_name1));
/// assert!(is_valid_string_cryptobacterium_curtum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cryptobacterium_curtum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cryptobacterium_curtum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469378"]),
        None,
        Some("."),
        Some("Ccur_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dethiosulfovibrio peptidovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469381.Dpep_0001";
/// let this_library_node_name2 = "469381.Dpep_2468";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dethiosulfovibrio_peptidovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_dethiosulfovibrio_peptidovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dethiosulfovibrio_peptidovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dethiosulfovibrio_peptidovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469381"]),
        None,
        Some("."),
        Some("Dpep_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halogeometricum borinquense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469382.Hbor_00010";
/// let this_library_node_name2 = "469382.Hbor_38060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halogeometricum_borinquense_node_name(this_library_node_name1));
/// assert!(is_valid_string_halogeometricum_borinquense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halogeometricum_borinquense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halogeometricum_borinquense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469382"]),
        None,
        Some("."),
        Some("Hbor_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Conexibacter woesei DSM14684 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469383.Cwoe_0001";
/// let this_library_node_name2 = "469383.Cwoe_5950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_conexibacter_woesei_dsm14684_node_name(this_library_node_name1));
/// assert!(is_valid_string_conexibacter_woesei_dsm14684_node_name(this_library_node_name2));
/// assert!(!is_valid_string_conexibacter_woesei_dsm14684_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_conexibacter_woesei_dsm14684_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469383"]),
        None,
        Some("."),
        Some("Cwoe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citrobacter sp. 302 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469595.CSAG_00001";
/// let this_library_node_name2 = "469595.CSAG_04910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citrobacter_sp_302_node_name(this_library_node_name1));
/// assert!(is_valid_string_citrobacter_sp_302_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citrobacter_sp_302_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citrobacter_sp_302_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469595"]),
        None,
        Some("."),
        Some("CSAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coprobacillus sp. 291 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469596.HMPREF9488_00001";
/// let this_library_node_name2 = "469596.HMPREF9488_03850";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coprobacillus_sp_291_node_name(this_library_node_name1));
/// assert!(is_valid_string_coprobacillus_sp_291_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coprobacillus_sp_291_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coprobacillus_sp_291_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469596"]),
        None,
        Some("."),
        Some("HMPREF9488_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium nucleatum vincentii 3136A2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469604.HMPREF0946_00001";
/// let this_library_node_name2 = "469604.HMPREF0946_02224";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_nucleatum_vincentii_3136a2_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_nucleatum_vincentii_3136a2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_nucleatum_vincentii_3136a2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_nucleatum_vincentii_3136a2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469604"]),
        None,
        Some("."),
        Some("HMPREF0946_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium nucleatum vincentii 4113 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469606.FSCG_00001";
/// let this_library_node_name2 = "469606.FSCG_02154";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_nucleatum_vincentii_4113_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_nucleatum_vincentii_4113_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_nucleatum_vincentii_4113_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_nucleatum_vincentii_4113_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469606"]),
        None,
        Some("."),
        Some("FSCG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. 2136FAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469609.HMPREF0847_00001";
/// let this_library_node_name2 = "469609.HMPREF0847_02170";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_2136faa_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_2136faa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_2136faa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_2136faa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469609"]),
        None,
        Some("."),
        Some("HMPREF0847_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderiales bacterium 1147 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469610.HMPREF0189_00001";
/// let this_library_node_name2 = "469610.HMPREF0189_02381";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderiales_bacterium_1147_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderiales_bacterium_1147_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderiales_bacterium_1147_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderiales_bacterium_1147_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469610"]),
        None,
        Some("."),
        Some("HMPREF0189_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium gonidiaformans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469615.FGAG_00001";
/// let this_library_node_name2 = "469615.FGAG_01621";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_gonidiaformans_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_gonidiaformans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_gonidiaformans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_gonidiaformans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469615"]),
        None,
        Some("."),
        Some("FGAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium mortiferum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469616.FMAG_00001";
/// let this_library_node_name2 = "469616.FMAG_02628";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_mortiferum_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_mortiferum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_mortiferum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_mortiferum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469616"]),
        None,
        Some("."),
        Some("FMAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium ulcerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469617.FUAG_00001";
/// let this_library_node_name2 = "469617.FUAG_03320";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_ulcerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_ulcerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_ulcerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_ulcerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469617"]),
        None,
        Some("."),
        Some("FUAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium varium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "469618.FVAG_00001";
/// let this_library_node_name2 = "469618.FVAG_03133";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_varium_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_varium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_varium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_varium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["469618"]),
        None,
        Some("."),
        Some("FVAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides coprocola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "470145.BACCOP_00001";
/// let this_library_node_name2 = "470145.BACCOP_04396";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_coprocola_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_coprocola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_coprocola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_coprocola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["470145"]),
        None,
        Some("."),
        Some("BACCOP_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cladophialophora yegresii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "470704.XP_007752233.1";
/// let this_library_node_name2 = "470704.XP_007762350.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cladophialophora_yegresii_node_name(this_library_node_name1));
/// assert!(is_valid_string_cladophialophora_yegresii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cladophialophora_yegresii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cladophialophora_yegresii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["470704"]),
        None,
        Some("."),
        Some("XP_0077"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacillus sp. WCH70 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471223.GWCH70_0001";
/// let this_library_node_name2 = "471223.GWCH70_3477";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacillus_sp_wch70_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacillus_sp_wch70_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacillus_sp_wch70_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacillus_sp_wch70_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471223"]),
        None,
        Some("."),
        Some("GWCH70_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermomonospora curvata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471852.Tcur_0001";
/// let this_library_node_name2 = "471852.Tcur_4985";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermomonospora_curvata_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermomonospora_curvata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermomonospora_curvata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermomonospora_curvata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471852"]),
        None,
        Some("."),
        Some("Tcur_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Beutenbergia cavernae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471853.Bcav_0001";
/// let this_library_node_name2 = "471853.Bcav_4225";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_beutenbergia_cavernae_node_name(this_library_node_name1));
/// assert!(is_valid_string_beutenbergia_cavernae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_beutenbergia_cavernae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_beutenbergia_cavernae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471853"]),
        None,
        Some("."),
        Some("Bcav_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dyadobacter fermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471854.Dfer_0001";
/// let this_library_node_name2 = "471854.Dfer_5804";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dyadobacter_fermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_dyadobacter_fermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dyadobacter_fermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dyadobacter_fermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471854"]),
        None,
        Some("."),
        Some("Dfer_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Slackia heliotrinireducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471855.Shel_00010";
/// let this_library_node_name2 = "471855.Shel_28560";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_slackia_heliotrinireducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_slackia_heliotrinireducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_slackia_heliotrinireducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_slackia_heliotrinireducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471855"]),
        None,
        Some("."),
        Some("Shel_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Jonesia denitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471856.Jden_0001";
/// let this_library_node_name2 = "471856.Jden_2558";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_jonesia_denitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_jonesia_denitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_jonesia_denitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_jonesia_denitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471856"]),
        None,
        Some("."),
        Some("Jden_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharomonospora viridis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471857.Svir_00010";
/// let this_library_node_name2 = "471857.Svir_39810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharomonospora_viridis_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharomonospora_viridis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharomonospora_viridis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharomonospora_viridis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471857"]),
        None,
        Some("."),
        Some("Svir_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides intestinalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471870.BACINT_00001";
/// let this_library_node_name2 = "471870.BACINT_04984";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_intestinalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_intestinalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_intestinalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_intestinalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471870"]),
        None,
        Some("."),
        Some("BACINT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Providencia stuartii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471874.PROSTU_00003";
/// let this_library_node_name2 = "471874.PROSTU_04860";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_providencia_stuartii_node_name(this_library_node_name1));
/// assert!(is_valid_string_providencia_stuartii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_providencia_stuartii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_providencia_stuartii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471874"]),
        None,
        Some("."),
        Some("PROSTU_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus lactaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471875.RUMLAC_00001";
/// let this_library_node_name2 = "471875.RUMLAC_02816";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_lactaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_lactaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_lactaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_lactaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471875"]),
        None,
        Some("."),
        Some("RUMLAC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Proteus penneri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "471881.PROPEN_00001";
/// let this_library_node_name2 = "471881.PROPEN_04997";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_proteus_penneri_node_name(this_library_node_name1));
/// assert!(is_valid_string_proteus_penneri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_proteus_penneri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_proteus_penneri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["471881"]),
        None,
        Some("."),
        Some("PROPEN_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitratireductor basaltis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "472175.EL18_00002";
/// let this_library_node_name2 = "472175.EL18_03494";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitratireductor_basaltis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitratireductor_basaltis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitratireductor_basaltis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitratireductor_basaltis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["472175"]),
        None,
        Some("."),
        Some("EL18_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosococcus halophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "472759.Nhal_0001";
/// let this_library_node_name2 = "472759.Nhal_4033";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosococcus_halophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosococcus_halophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosococcus_halophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosococcus_halophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["472759"]),
        None,
        Some("."),
        Some("Nhal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Colletotrichum gloeosporioides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "474922.ELA23096";
/// let this_library_node_name2 = "474922.ELA38476";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_colletotrichum_gloeosporioides_node_name(this_library_node_name1));
/// assert!(is_valid_string_colletotrichum_gloeosporioides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_colletotrichum_gloeosporioides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_colletotrichum_gloeosporioides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["474922"]),
        None,
        Some("."),
        Some("ELA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blautia hydrogenotrophica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "476272.RUMHYD_00001";
/// let this_library_node_name2 = "476272.RUMHYD_03933";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blautia_hydrogenotrophica_node_name(this_library_node_name1));
/// assert!(is_valid_string_blautia_hydrogenotrophica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blautia_hydrogenotrophica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blautia_hydrogenotrophica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["476272"]),
        None,
        Some("."),
        Some("RUMHYD_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Achromobacter arsenitoxydans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "477184.KYC_00005";
/// let this_library_node_name2 = "477184.KYC_28817";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_achromobacter_arsenitoxydans_node_name(this_library_node_name1));
/// assert!(is_valid_string_achromobacter_arsenitoxydans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_achromobacter_arsenitoxydans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_achromobacter_arsenitoxydans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["477184"]),
        None,
        Some("."),
        Some("KYC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas stutzeri TS44 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "477228.YO5_00005";
/// let this_library_node_name2 = "477228.YO5_20236";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_stutzeri_ts44_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_stutzeri_ts44_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_stutzeri_ts44_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_stutzeri_ts44_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["477228"]),
        None,
        Some("."),
        Some("YO5_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Modestobacter marinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "477641.MODMU_0001";
/// let this_library_node_name2 = "477641.MODMU_5597";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_modestobacter_marinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_modestobacter_marinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_modestobacter_marinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_modestobacter_marinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["477641"]),
        None,
        Some("."),
        Some("MODMU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulforudis audaxviator nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "477974.Daud_0001";
/// let this_library_node_name2 = "477974.Daud_2239";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulforudis_audaxviator_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulforudis_audaxviator_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulforudis_audaxviator_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulforudis_audaxviator_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["477974"]),
        None,
        Some("."),
        Some("Daud_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Verrucomicrobia bacterium LP2A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "478741.JAFS01000001_gene1045";
/// let this_library_node_name2 = "478741.JAFS01000003_gene2234";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_verrucomicrobia_bacterium_lp2a_node_name(this_library_node_name1));
/// assert!(is_valid_string_verrucomicrobia_bacterium_lp2a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_verrucomicrobia_bacterium_lp2a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_verrucomicrobia_bacterium_lp2a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["478741"]),
        None,
        Some("."),
        Some("JAFS0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marvinbryantia formatexigens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "478749.BRYFOR_05000";
/// let this_library_node_name2 = "478749.BRYFOR_09960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marvinbryantia_formatexigens_node_name(this_library_node_name1));
/// assert!(is_valid_string_marvinbryantia_formatexigens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marvinbryantia_formatexigens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marvinbryantia_formatexigens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["478749"]),
        None,
        Some("."),
        Some("BRYFOR_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kytococcus sedentarius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "478801.Ksed_00010";
/// let this_library_node_name2 = "478801.Ksed_27040";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kytococcus_sedentarius_node_name(this_library_node_name1));
/// assert!(is_valid_string_kytococcus_sedentarius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kytococcus_sedentarius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kytococcus_sedentarius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["478801"]),
        None,
        Some("."),
        Some("Ksed_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nakamurella multipartita nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "479431.Namu_0001";
/// let this_library_node_name2 = "479431.Namu_5415";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nakamurella_multipartita_node_name(this_library_node_name1));
/// assert!(is_valid_string_nakamurella_multipartita_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nakamurella_multipartita_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nakamurella_multipartita_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["479431"]),
        None,
        Some("."),
        Some("Namu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptosporangium roseum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "479432.Sros_0001";
/// let this_library_node_name2 = "479432.Sros_9421";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptosporangium_roseum_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptosporangium_roseum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptosporangium_roseum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptosporangium_roseum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["479432"]),
        None,
        Some("."),
        Some("Sros_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Catenulispora acidiphila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "479433.Caci_0001";
/// let this_library_node_name2 = "479433.Caci_9056";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_catenulispora_acidiphila_node_name(this_library_node_name1));
/// assert!(is_valid_string_catenulispora_acidiphila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_catenulispora_acidiphila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_catenulispora_acidiphila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["479433"]),
        None,
        Some("."),
        Some("Caci_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphaerobacter thermophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "479434.Sthe_0001";
/// let this_library_node_name2 = "479434.Sthe_3525";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphaerobacter_thermophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphaerobacter_thermophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphaerobacter_thermophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphaerobacter_thermophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["479434"]),
        None,
        Some("."),
        Some("Sthe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kribbella flavida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "479435.Kfla_0001";
/// let this_library_node_name2 = "479435.Kfla_7086";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kribbella_flavida_node_name(this_library_node_name1));
/// assert!(is_valid_string_kribbella_flavida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kribbella_flavida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kribbella_flavida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["479435"]),
        None,
        Some("."),
        Some("Kfla_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Veillonella parvula nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "479436.Vpar_0001";
/// let this_library_node_name2 = "479436.Vpar_1859";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_veillonella_parvula_node_name(this_library_node_name1));
/// assert!(is_valid_string_veillonella_parvula_node_name(this_library_node_name2));
/// assert!(!is_valid_string_veillonella_parvula_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_veillonella_parvula_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["479436"]),
        None,
        Some("."),
        Some("Vpar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eggerthella lenta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "479437.Elen_0001";
/// let this_library_node_name2 = "479437.Elen_3123";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eggerthella_lenta_node_name(this_library_node_name1));
/// assert!(is_valid_string_eggerthella_lenta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eggerthella_lenta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eggerthella_lenta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["479437"]),
        None,
        Some("."),
        Some("Elen_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylacidiphilum infernorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "481448.Minf_0001";
/// let this_library_node_name2 = "481448.Minf_2478";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylacidiphilum_infernorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylacidiphilum_infernorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylacidiphilum_infernorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylacidiphilum_infernorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["481448"]),
        None,
        Some("."),
        Some("Minf_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia coli ATCC8739 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "481805.EcolC_0001";
/// let this_library_node_name2 = "481805.EcolC_4292";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_coli_atcc8739_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_coli_atcc8739_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_coli_atcc8739_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_coli_atcc8739_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["481805"]),
        None,
        Some("."),
        Some("EcolC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus canis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "482234.SCAZ3_00005";
/// let this_library_node_name2 = "482234.SCAZ3_11535";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_canis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_canis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_canis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_canis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["482234"]),
        None,
        Some("."),
        Some("SCAZ3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Galeopterus variegatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "482537.XP_008561230.1";
/// let this_library_node_name2 = "482537.XP_008593319.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_galeopterus_variegatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_galeopterus_variegatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_galeopterus_variegatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_galeopterus_variegatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["482537"]),
        None,
        Some("."),
        Some("XP_0085"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides finegoldii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "483215.BACFIN_04700";
/// let this_library_node_name2 = "483215.BACFIN_09256";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_finegoldii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_finegoldii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_finegoldii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_finegoldii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["483215"]),
        None,
        Some("."),
        Some("BACFIN_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides eggerthii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "483216.BACEGG_00001";
/// let this_library_node_name2 = "483216.BACEGG_03771";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_eggerthii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_eggerthii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_eggerthii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_eggerthii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["483216"]),
        None,
        Some("."),
        Some("BACEGG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides pectinophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "483218.BACPEC_00001";
/// let this_library_node_name2 = "483218.BACPEC_03294";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_pectinophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_pectinophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_pectinophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_pectinophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["483218"]),
        None,
        Some("."),
        Some("BACPEC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myxococcus fulvus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "483219.LILAB_00005";
/// let this_library_node_name2 = "483219.LILAB_36725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myxococcus_fulvus_node_name(this_library_node_name1));
/// assert!(is_valid_string_myxococcus_fulvus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myxococcus_fulvus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myxococcus_fulvus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["483219"]),
        None,
        Some("."),
        Some("LILAB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides plebeius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "484018.BACPLE_00001";
/// let this_library_node_name2 = "484018.BACPLE_04024";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_plebeius_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_plebeius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_plebeius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_plebeius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["484018"]),
        None,
        Some("."),
        Some("BACPLE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermosipho africanus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "484019.THA_1";
/// let this_library_node_name2 = "484019.THA_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermosipho_africanus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermosipho_africanus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermosipho_africanus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermosipho_africanus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["484019"]),
        None,
        Some("."),
        Some("THA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Francisella philomiragia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "484022.Fphi_0001";
/// let this_library_node_name2 = "484022.Fphi_1931";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_francisella_philomiragia_node_name(this_library_node_name1));
/// assert!(is_valid_string_francisella_philomiragia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_francisella_philomiragia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_francisella_philomiragia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["484022"]),
        None,
        Some("."),
        Some("Fphi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelosinus sp. UFO1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "484770.UFO1_0005";
/// let this_library_node_name2 = "484770.UFO1_4789";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelosinus_sp_ufo1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelosinus_sp_ufo1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelosinus_sp_ufo1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelosinus_sp_ufo1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["484770"]),
        None,
        Some("."),
        Some("UFO1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ktedonobacter racemifer nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "485913.Krac_0001";
/// let this_library_node_name2 = "485913.Krac_R0025";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ktedonobacter_racemifer_node_name(this_library_node_name1));
/// assert!(is_valid_string_ktedonobacter_racemifer_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ktedonobacter_racemifer_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ktedonobacter_racemifer_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["485913"]),
        None,
        Some("."),
        Some("Krac_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomicrobium mukohataei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "485914.Hmuk_0001";
/// let this_library_node_name2 = "485914.Hmuk_3416";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomicrobium_mukohataei_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomicrobium_mukohataei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomicrobium_mukohataei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomicrobium_mukohataei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["485914"]),
        None,
        Some("."),
        Some("Hmuk_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfohalobium retbaense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "485915.Dret_0001";
/// let this_library_node_name2 = "485915.Dret_2552";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfohalobium_retbaense_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfohalobium_retbaense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfohalobium_retbaense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfohalobium_retbaense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["485915"]),
        None,
        Some("."),
        Some("Dret_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum acetoxidans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "485916.Dtox_0001";
/// let this_library_node_name2 = "485916.Dtox_4370";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_acetoxidans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_acetoxidans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_acetoxidans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_acetoxidans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["485916"]),
        None,
        Some("."),
        Some("Dtox_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pedobacter heparinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "485917.Phep_0001";
/// let this_library_node_name2 = "485917.Phep_4287";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pedobacter_heparinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pedobacter_heparinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pedobacter_heparinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pedobacter_heparinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["485917"]),
        None,
        Some("."),
        Some("Phep_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chitinophaga pinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "485918.Cpin_0001";
/// let this_library_node_name2 = "485918.Cpin_7302";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chitinophaga_pinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_chitinophaga_pinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chitinophaga_pinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chitinophaga_pinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["485918"]),
        None,
        Some("."),
        Some("Cpin_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter soli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "487316.BBNM01000001_gene1439";
/// let this_library_node_name2 = "487316.BBNM01000033_gene120";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_soli_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_soli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_soli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_soli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["487316"]),
        None,
        Some("."),
        Some("BBNM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium intracellulare nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "487521.OCU_00010";
/// let this_library_node_name2 = "487521.OCU_51450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_intracellulare_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_intracellulare_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_intracellulare_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_intracellulare_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["487521"]),
        None,
        Some("."),
        Some("OCU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacteria bacterium MS0242A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "487796.Flav2ADRAFT_0001";
/// let this_library_node_name2 = "487796.Flav2ADRAFT_1780";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacteria_bacterium_ms0242a_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacteria_bacterium_ms0242a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacteria_bacterium_ms0242a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacteria_bacterium_ms0242a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["487796"]),
        None,
        Some("."),
        Some("Flav2ADRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Puniceispirillum marinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "488538.SAR116_0001";
/// let this_library_node_name2 = "488538.SAR116_2546";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_puniceispirillum_marinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_puniceispirillum_marinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_puniceispirillum_marinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_puniceispirillum_marinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["488538"]),
        None,
        Some("."),
        Some("SAR116_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria lactamica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "489653.NLA_0010";
/// let this_library_node_name2 = "489653.NLA_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_lactamica_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_lactamica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_lactamica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_lactamica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["489653"]),
        None,
        Some("."),
        Some("NLA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moorea producens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "489825.LYNGBM3L_00100";
/// let this_library_node_name2 = "489825.LYNGBM3L_76090";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moorea_producens_node_name(this_library_node_name1));
/// assert!(is_valid_string_moorea_producens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moorea_producens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moorea_producens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["489825"]),
        None,
        Some("."),
        Some("LYNGBM3L_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfurococcus kamchatkensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "490899.DKAM_0001";
/// let this_library_node_name2 = "490899.DKAM_1474";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfurococcus_kamchatkensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfurococcus_kamchatkensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfurococcus_kamchatkensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfurococcus_kamchatkensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["490899"]),
        None,
        Some("."),
        Some("DKAM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium hispalense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "491205.JARQ01000001_gene1000";
/// let this_library_node_name2 = "491205.JARQ01000028_gene1236";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_hispalense_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_hispalense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_hispalense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_hispalense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["491205"]),
        None,
        Some("."),
        Some("JARQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anoxybacillus flavithermus WK1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "491915.Aflv_0001";
/// let this_library_node_name2 = "491915.Aflv_2863";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anoxybacillus_flavithermus_wk1_node_name(this_library_node_name1));
/// assert!(is_valid_string_anoxybacillus_flavithermus_wk1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anoxybacillus_flavithermus_wk1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anoxybacillus_flavithermus_wk1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["491915"]),
        None,
        Some("."),
        Some("Aflv_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium etli CIAT652 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "491916.RHECIAT_CH0000001";
/// let this_library_node_name2 = "491916.RHECIAT_PC0000989";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_etli_ciat652_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_etli_ciat652_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_etli_ciat652_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_etli_ciat652_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["491916"]),
        None,
        Some("."),
        Some("RHECIAT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinomonas posidonica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "491952.Mar181_0001";
/// let this_library_node_name2 = "491952.Mar181_3544";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinomonas_posidonica_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinomonas_posidonica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinomonas_posidonica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinomonas_posidonica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["491952"]),
        None,
        Some("."),
        Some("Mar181_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium alamii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "492774.JQMB01000001_gene5588";
/// let this_library_node_name2 = "492774.JQMB01000033_gene3501";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_alamii_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_alamii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_alamii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_alamii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["492774"]),
        None,
        Some("."),
        Some("JQMB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glaciecola arctica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "493475.GARC_0003";
/// let this_library_node_name2 = "493475.GARC_5382";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glaciecola_arctica_node_name(this_library_node_name1));
/// assert!(is_valid_string_glaciecola_arctica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glaciecola_arctica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glaciecola_arctica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["493475"]),
        None,
        Some("."),
        Some("GARC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter sp. TB15 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "494416.AYXN01000001_gene2377";
/// let this_library_node_name2 = "494416.AYXN01000043_gene1628";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_sp_tb15_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_sp_tb15_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_sp_tb15_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_sp_tb15_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["494416"]),
        None,
        Some("."),
        Some("AYXN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. TB23 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "494419.ALPM01000001_gene1820";
/// let this_library_node_name2 = "494419.ALPM01000126_gene1217";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_tb23_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_tb23_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_tb23_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_tb23_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["494419"]),
        None,
        Some("."),
        Some("ALPM01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma fermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "496833.MBIO_0001";
/// let this_library_node_name2 = "496833.MBIO_0893";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_fermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_fermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_fermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_fermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["496833"]),
        None,
        Some("."),
        Some("MBIO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thauera sp. 63 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "497321.C664_00005";
/// let this_library_node_name2 = "497321.C664_20205";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thauera_sp_63_node_name(this_library_node_name1));
/// assert!(is_valid_string_thauera_sp_63_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thauera_sp_63_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thauera_sp_63_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["497321"]),
        None,
        Some("."),
        Some("C664_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chthoniobacter flavus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "497964.CfE428DRAFT_0001";
/// let this_library_node_name2 = "497964.CfE428DRAFT_6720";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chthoniobacter_flavus_node_name(this_library_node_name1));
/// assert!(is_valid_string_chthoniobacter_flavus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chthoniobacter_flavus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chthoniobacter_flavus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["497964"]),
        None,
        Some("."),
        Some("CfE428DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanothece sp. PCC7822 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "497965.Cyan7822_0001";
/// let this_library_node_name2 = "497965.Cyan7822_6705";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanothece_sp_pcc7822_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanothece_sp_pcc7822_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanothece_sp_pcc7822_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanothece_sp_pcc7822_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["497965"]),
        None,
        Some("."),
        Some("Cyan7822_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellvibrio japonicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "498211.CJA_0001";
/// let this_library_node_name2 = "498211.CJA_3826";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellvibrio_japonicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellvibrio_japonicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellvibrio_japonicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellvibrio_japonicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["498211"]),
        None,
        Some("."),
        Some("CJA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia spielmanii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "498742.BSPA14S_0004";
/// let this_library_node_name2 = "498742.BSPA14S_PA0001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_spielmanii_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_spielmanii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_spielmanii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_spielmanii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["498742"]),
        None,
        Some("."),
        Some("BSPA14S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Heliobacterium modesticaldum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "498761.HM1_0001";
/// let this_library_node_name2 = "498761.HM1_3154";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_heliobacterium_modesticaldum_node_name(this_library_node_name1));
/// assert!(is_valid_string_heliobacterium_modesticaldum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_heliobacterium_modesticaldum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_heliobacterium_modesticaldum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["498761"]),
        None,
        Some("."),
        Some("HM1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus aquaticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "498848.TaqDRAFT_3001";
/// let this_library_node_name2 = "498848.TaqDRAFT_5541";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_aquaticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_aquaticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_aquaticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_aquaticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["498848"]),
        None,
        Some("."),
        Some("TaqDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces avicenniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "500153.JOEK01000001_gene3479";
/// let this_library_node_name2 = "500153.JOEK01000065_gene2869";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_avicenniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_avicenniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_avicenniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_avicenniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["500153"]),
        None,
        Some("."),
        Some("JOEK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tyzzerella nexilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "500632.CLONEX_00001";
/// let this_library_node_name2 = "500632.CLONEX_04301";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tyzzerella_nexilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_tyzzerella_nexilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tyzzerella_nexilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tyzzerella_nexilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["500632"]),
        None,
        Some("."),
        Some("CLONEX_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium hiranonis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "500633.CLOHIR_00003";
/// let this_library_node_name2 = "500633.CLOHIR_02295";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_hiranonis_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_hiranonis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_hiranonis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_hiranonis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["500633"]),
        None,
        Some("."),
        Some("CLOHIR_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mitsuokella multacida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "500635.MITSMUL_03001";
/// let this_library_node_name2 = "500635.MITSMUL_05650";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mitsuokella_multacida_node_name(this_library_node_name1));
/// assert!(is_valid_string_mitsuokella_multacida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mitsuokella_multacida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mitsuokella_multacida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["500635"]),
        None,
        Some("."),
        Some("MITSMUL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Providencia rustigianii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "500637.PROVRUST_04500";
/// let this_library_node_name2 = "500637.PROVRUST_08571";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_providencia_rustigianii_node_name(this_library_node_name1));
/// assert!(is_valid_string_providencia_rustigianii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_providencia_rustigianii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_providencia_rustigianii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["500637"]),
        None,
        Some("."),
        Some("PROVRUST_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citrobacter youngae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "500640.CIT292_05900";
/// let this_library_node_name2 = "500640.CIT292_11307";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citrobacter_youngae_node_name(this_library_node_name1));
/// assert!(is_valid_string_citrobacter_youngae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citrobacter_youngae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citrobacter_youngae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["500640"]),
        None,
        Some("."),
        Some("CIT292_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citreicella sp. SE45 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "501479.ACNW01000001_gene1406";
/// let this_library_node_name2 = "501479.ACNW01000122_gene2991";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citreicella_sp_se45_node_name(this_library_node_name1));
/// assert!(is_valid_string_citreicella_sp_se45_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citreicella_sp_se45_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citreicella_sp_se45_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["501479"]),
        None,
        Some("."),
        Some("ACNW01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haliangium ochraceum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "502025.Hoch_0001";
/// let this_library_node_name2 = "502025.Hoch_6898";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haliangium_ochraceum_node_name(this_library_node_name1));
/// assert!(is_valid_string_haliangium_ochraceum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haliangium_ochraceum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haliangium_ochraceum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["502025"]),
        None,
        Some("."),
        Some("Hoch_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia albertii TW07627 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "502347.ESCAB7627_0006";
/// let this_library_node_name2 = "502347.ESCAB7627_4880";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_albertii_tw07627_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_albertii_tw07627_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_albertii_tw07627_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_albertii_tw07627_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["502347"]),
        None,
        Some("."),
        Some("ESCAB7627_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eggerthella sp. YY7918 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "502558.EGYY_00010";
/// let this_library_node_name2 = "502558.EGYY_30400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eggerthella_sp_yy7918_node_name(this_library_node_name1));
/// assert!(is_valid_string_eggerthella_sp_yy7918_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eggerthella_sp_yy7918_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eggerthella_sp_yy7918_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["502558"]),
        None,
        Some("."),
        Some("EGYY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirosoma linguale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "504472.Slin_0001";
/// let this_library_node_name2 = "504472.Slin_7050";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirosoma_linguale_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirosoma_linguale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirosoma_linguale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirosoma_linguale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["504472"]),
        None,
        Some("."),
        Some("Slin_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium urealyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "504474.cu0001";
/// let this_library_node_name2 = "504474.cu2027";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_urealyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_urealyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_urealyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_urealyticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["504474"]),
        None,
        Some("."),
        Some("cu"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Jejuia pallidilutea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "504487.693562153";
/// let this_library_node_name2 = "504487.JCM19302_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_jejuia_pallidilutea_node_name(this_library_node_name1));
/// assert!(is_valid_string_jejuia_pallidilutea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_jejuia_pallidilutea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_jejuia_pallidilutea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["504487"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Meiothermus ruber nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "504728.K649_00005";
/// let this_library_node_name2 = "504728.K649_15420";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_meiothermus_ruber_node_name(this_library_node_name1));
/// assert!(is_valid_string_meiothermus_ruber_node_name(this_library_node_name2));
/// assert!(!is_valid_string_meiothermus_ruber_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_meiothermus_ruber_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["504728"]),
        None,
        Some("."),
        Some("K649_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oligotropha carboxidovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "504832.OCAR_4001";
/// let this_library_node_name2 = "504832.OCAR_7779";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oligotropha_carboxidovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_oligotropha_carboxidovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oligotropha_carboxidovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oligotropha_carboxidovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["504832"]),
        None,
        Some("."),
        Some("OCAR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rheinheimera sp. A13L nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "506534.Rhein_0001";
/// let this_library_node_name2 = "506534.Rhein_4026";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rheinheimera_sp_a13l_node_name(this_library_node_name1));
/// assert!(is_valid_string_rheinheimera_sp_a13l_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rheinheimera_sp_a13l_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rheinheimera_sp_a13l_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["506534"]),
        None,
        Some("."),
        Some("Rhein_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caulobacter segnis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "509190.Cseg_0001";
/// let this_library_node_name2 = "509190.Cseg_4267";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caulobacter_segnis_node_name(this_library_node_name1));
/// assert!(is_valid_string_caulobacter_segnis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caulobacter_segnis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caulobacter_segnis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["509190"]),
        None,
        Some("."),
        Some("Cseg_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetivibrio cellulolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "509191.AEDB02000001_gene1305";
/// let this_library_node_name2 = "509191.AEDB02000112_gene4913";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetivibrio_cellulolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetivibrio_cellulolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetivibrio_cellulolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetivibrio_cellulolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["509191"]),
        None,
        Some("."),
        Some("AEDB02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pedobacter sp. V48 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "509635.N824_00010";
/// let this_library_node_name2 = "509635.N824_29805";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pedobacter_sp_v48_node_name(this_library_node_name1));
/// assert!(is_valid_string_pedobacter_sp_v48_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pedobacter_sp_v48_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pedobacter_sp_v48_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["509635"]),
        None,
        Some("."),
        Some("N824_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldisericum exile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "511051.CSE_00010";
/// let this_library_node_name2 = "511051.CSE_15820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldisericum_exile_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldisericum_exile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldisericum_exile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldisericum_exile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["511051"]),
        None,
        Some("."),
        Some("CSE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanimonas sp. GK1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "511062.GU3_00005";
/// let this_library_node_name2 = "511062.GU3_16344";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanimonas_sp_gk1_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanimonas_sp_gk1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanimonas_sp_gk1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanimonas_sp_gk1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["511062"]),
        None,
        Some("."),
        Some("GU3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia coli K12 MG1655 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "511145.b0001";
/// let this_library_node_name2 = "511145.b4706";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_coli_k12_mg1655_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_coli_k12_mg1655_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_coli_k12_mg1655_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_coli_k12_mg1655_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["511145"]),
        None,
        Some("."),
        Some("b"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus buchneri NRRLB30929 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "511437.Lbuc_0001";
/// let this_library_node_name2 = "511437.Lbuc_2424";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_buchneri_nrrlb30929_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_buchneri_nrrlb30929_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_buchneri_nrrlb30929_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_buchneri_nrrlb30929_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["511437"]),
        None,
        Some("."),
        Some("Lbuc_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio crossotus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "511680.BUTYVIB_00001";
/// let this_library_node_name2 = "511680.BUTYVIB_02579";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_crossotus_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_crossotus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_crossotus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_crossotus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["511680"]),
        None,
        Some("."),
        Some("BUTYVIB_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Azobacteroides pseudotrichonymphae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "511995.CFPG_001";
/// let this_library_node_name2 = "511995.CFPG_P4-4";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_azobacteroides_pseudotrichonymphae_node_name(this_library_node_name1));
/// assert!(is_valid_string_azobacteroides_pseudotrichonymphae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_azobacteroides_pseudotrichonymphae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_azobacteroides_pseudotrichonymphae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["511995"]),
        None,
        Some("."),
        Some("CFPG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma crocodyli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "512564.MCRO_0001";
/// let this_library_node_name2 = "512564.MCRO_0777";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_crocodyli_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_crocodyli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_crocodyli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_crocodyli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["512564"]),
        None,
        Some("."),
        Some("MCRO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinoplanes missouriensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "512565.AMIS_10";
/// let this_library_node_name2 = "512565.AMIS_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinoplanes_missouriensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinoplanes_missouriensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinoplanes_missouriensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinoplanes_missouriensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["512565"]),
        None,
        Some("."),
        Some("AMIS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Riesia pediculicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "515618.RIEPE_0002";
/// let this_library_node_name2 = "515618.RIEPE_A0012";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_riesia_pediculicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_riesia_pediculicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_riesia_pediculicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_riesia_pediculicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["515618"]),
        None,
        Some("."),
        Some("RIEPE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium eligens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "515620.EUBELI_00001";
/// let this_library_node_name2 = "515620.EUBELI_20667";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_eligens_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_eligens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_eligens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_eligens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["515620"]),
        None,
        Some("."),
        Some("EUBELI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio proteoclasticus B316 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "515622.bpr_I0001";
/// let this_library_node_name2 = "515622.bpr_IV199";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_proteoclasticus_b316_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_proteoclasticus_b316_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_proteoclasticus_b316_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_proteoclasticus_b316_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["515622"]),
        None,
        Some("."),
        Some("bpr_I"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dictyoglomus turgidum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "515635.Dtur_0001";
/// let this_library_node_name2 = "515635.Dtur_1814";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dictyoglomus_turgidum_node_name(this_library_node_name1));
/// assert!(is_valid_string_dictyoglomus_turgidum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dictyoglomus_turgidum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dictyoglomus_turgidum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["515635"]),
        None,
        Some("."),
        Some("Dtur_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorobaculum parvum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "517417.Cpar_0001";
/// let this_library_node_name2 = "517417.Cpar_2087";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorobaculum_parvum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorobaculum_parvum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorobaculum_parvum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorobaculum_parvum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["517417"]),
        None,
        Some("."),
        Some("Cpar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chloroherpeton thalassium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "517418.Ctha_0001";
/// let this_library_node_name2 = "517418.Ctha_2733";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chloroherpeton_thalassium_node_name(this_library_node_name1));
/// assert!(is_valid_string_chloroherpeton_thalassium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chloroherpeton_thalassium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chloroherpeton_thalassium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["517418"]),
        None,
        Some("."),
        Some("Ctha_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea sp. aB nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "517433.PanABDRAFT_0001";
/// let this_library_node_name2 = "517433.PanABDRAFT_4493";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_sp_ab_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_sp_ab_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_sp_ab_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_sp_ab_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["517433"]),
        None,
        Some("."),
        Some("PanABDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citromicrobium sp. JLT1363 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "517722.AEUE01000001_gene2419";
/// let this_library_node_name2 = "517722.AEUE01000026_gene2878";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citromicrobium_sp_jlt1363_node_name(this_library_node_name1));
/// assert!(is_valid_string_citromicrobium_sp_jlt1363_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citromicrobium_sp_jlt1363_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citromicrobium_sp_jlt1363_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["517722"]),
        None,
        Some("."),
        Some("AEUE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium angulatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "518635.BIFANG_02000";
/// let this_library_node_name2 = "518635.BIFANG_03810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_angulatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_angulatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_angulatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_angulatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["518635"]),
        None,
        Some("."),
        Some("BIFANG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Holdemanella biformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "518637.EUBIFOR_00003";
/// let this_library_node_name2 = "518637.EUBIFOR_02578";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_holdemanella_biformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_holdemanella_biformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_holdemanella_biformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_holdemanella_biformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["518637"]),
        None,
        Some("."),
        Some("EUBIFOR_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodothermus marinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "518766.Rmar_0001";
/// let this_library_node_name2 = "518766.Rmar_2914";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodothermus_marinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodothermus_marinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodothermus_marinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodothermus_marinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["518766"]),
        None,
        Some("."),
        Some("Rmar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptobacillus moniliformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "519441.Smon_0001";
/// let this_library_node_name2 = "519441.Smon_1511";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptobacillus_moniliformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptobacillus_moniliformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptobacillus_moniliformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptobacillus_moniliformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["519441"]),
        None,
        Some("."),
        Some("Smon_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halorhabdus utahensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "519442.Huta_0001";
/// let this_library_node_name2 = "519442.Huta_3027";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halorhabdus_utahensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_halorhabdus_utahensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halorhabdus_utahensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halorhabdus_utahensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["519442"]),
        None,
        Some("."),
        Some("Huta_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ectothiorhodospira sp. PHS1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "519989.ECTPHS_00005";
/// let this_library_node_name2 = "519989.ECTPHS_14260";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ectothiorhodospira_sp_phs1_node_name(this_library_node_name1));
/// assert!(is_valid_string_ectothiorhodospira_sp_phs1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ectothiorhodospira_sp_phs1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ectothiorhodospira_sp_phs1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["519989"]),
        None,
        Some("."),
        Some("ECTPHS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. NIPH973 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "520709.F985_00001";
/// let this_library_node_name2 = "520709.F985_04135";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_niph973_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_niph973_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_niph973_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_niph973_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["520709"]),
        None,
        Some("."),
        Some("F985_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Providencia alcalifaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "520999.PROVALCAL_00001";
/// let this_library_node_name2 = "520999.PROVALCAL_04089";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_providencia_alcalifaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_providencia_alcalifaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_providencia_alcalifaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_providencia_alcalifaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["520999"]),
        None,
        Some("."),
        Some("PROVALCAL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Providencia rettgeri DSM1131 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521000.PROVRETT_05300";
/// let this_library_node_name2 = "521000.PROVRETT_10152";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_providencia_rettgeri_dsm1131_node_name(this_library_node_name1));
/// assert!(is_valid_string_providencia_rettgeri_dsm1131_node_name(this_library_node_name2));
/// assert!(!is_valid_string_providencia_rettgeri_dsm1131_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_providencia_rettgeri_dsm1131_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521000"]),
        None,
        Some("."),
        Some("PROVRETT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Collinsella intestinalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521003.COLINT_01956";
/// let this_library_node_name2 = "521003.COLINT_03795";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_collinsella_intestinalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_collinsella_intestinalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_collinsella_intestinalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_collinsella_intestinalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521003"]),
        None,
        Some("."),
        Some("COLINT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia bissettii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521010.BbiDN127_0001";
/// let this_library_node_name2 = "521010.BbiDN127_B0027";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_bissettii_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_bissettii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_bissettii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_bissettii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521010"]),
        None,
        Some("."),
        Some("BbiDN127_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanosphaerula palustris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521011.Mpal_0001";
/// let this_library_node_name2 = "521011.Mpal_2796";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanosphaerula_palustris_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanosphaerula_palustris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanosphaerula_palustris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanosphaerula_palustris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521011"]),
        None,
        Some("."),
        Some("Mpal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kosmotoga olearia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521045.Kole_0001";
/// let this_library_node_name2 = "521045.Kole_2170";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kosmotoga_olearia_node_name(this_library_node_name1));
/// assert!(is_valid_string_kosmotoga_olearia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kosmotoga_olearia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kosmotoga_olearia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521045"]),
        None,
        Some("."),
        Some("Kole_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atopobium parvulum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521095.Apar_0001";
/// let this_library_node_name2 = "521095.Apar_1369";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atopobium_parvulum_node_name(this_library_node_name1));
/// assert!(is_valid_string_atopobium_parvulum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atopobium_parvulum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atopobium_parvulum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521095"]),
        None,
        Some("."),
        Some("Apar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tsukamurella paurometabola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521096.Tpau_0001";
/// let this_library_node_name2 = "521096.Tpau_4335";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tsukamurella_paurometabola_node_name(this_library_node_name1));
/// assert!(is_valid_string_tsukamurella_paurometabola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tsukamurella_paurometabola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tsukamurella_paurometabola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521096"]),
        None,
        Some("."),
        Some("Tpau_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga ochracea DSM7271 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521097.Coch_0001";
/// let this_library_node_name2 = "521097.Coch_2193";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_ochracea_dsm7271_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_ochracea_dsm7271_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_ochracea_dsm7271_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_ochracea_dsm7271_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521097"]),
        None,
        Some("."),
        Some("Coch_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alicyclobacillus acidocaldarius DSM446 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521098.Aaci_0001";
/// let this_library_node_name2 = "521098.Aaci_3147";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alicyclobacillus_acidocaldarius_dsm446_node_name(this_library_node_name1));
/// assert!(is_valid_string_alicyclobacillus_acidocaldarius_dsm446_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alicyclobacillus_acidocaldarius_dsm446_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alicyclobacillus_acidocaldarius_dsm446_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521098"]),
        None,
        Some("."),
        Some("Aaci_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces timonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521393.JH806632_gene1";
/// let this_library_node_name2 = "521393.JH806634_gene2385";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_timonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_timonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_timonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_timonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521393"]),
        None,
        Some("."),
        Some("JH80663"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldicellulosiruptor bescii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521460.Athe_0001";
/// let this_library_node_name2 = "521460.Athe_2780";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldicellulosiruptor_bescii_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldicellulosiruptor_bescii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldicellulosiruptor_bescii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldicellulosiruptor_bescii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521460"]),
        None,
        Some("."),
        Some("Athe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Planctomyces limnophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521674.Plim_0001";
/// let this_library_node_name2 = "521674.Plim_4304";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_planctomyces_limnophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_planctomyces_limnophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_planctomyces_limnophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_planctomyces_limnophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521674"]),
        None,
        Some("."),
        Some("Plim_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas caeni nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "521719.ATXQ01000001_gene256";
/// let this_library_node_name2 = "521719.ATXQ01000024_gene161";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_caeni_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_caeni_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_caeni_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_caeni_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["521719"]),
        None,
        Some("."),
        Some("ATXQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Accumulibacter phosphatis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "522306.CAP2UW1_0001";
/// let this_library_node_name2 = "522306.CAP2UW1_4567";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_accumulibacter_phosphatis_node_name(this_library_node_name1));
/// assert!(is_valid_string_accumulibacter_phosphatis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_accumulibacter_phosphatis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_accumulibacter_phosphatis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["522306"]),
        None,
        Some("."),
        Some("CAP2UW1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stenotrophomonas maltophilia K279a nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "522373.Smlt0001";
/// let this_library_node_name2 = "522373.Smlt4695";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stenotrophomonas_maltophilia_k279a_node_name(this_library_node_name1));
/// assert!(is_valid_string_stenotrophomonas_maltophilia_k279a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stenotrophomonas_maltophilia_k279a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stenotrophomonas_maltophilia_k279a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["522373"]),
        None,
        Some("."),
        Some("Smlt"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Denitrovibrio acetiphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "522772.Dacet_0001";
/// let this_library_node_name2 = "522772.Dacet_3021";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_denitrovibrio_acetiphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_denitrovibrio_acetiphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_denitrovibrio_acetiphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_denitrovibrio_acetiphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["522772"]),
        None,
        Some("."),
        Some("Dacet_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kangiella koreensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "523791.Kkor_0001";
/// let this_library_node_name2 = "523791.Kkor_2647";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kangiella_koreensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_kangiella_koreensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kangiella_koreensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kangiella_koreensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["523791"]),
        None,
        Some("."),
        Some("Kkor_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptotrichia buccalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "523794.Lebu_0001";
/// let this_library_node_name2 = "523794.Lebu_2306";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptotrichia_buccalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptotrichia_buccalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptotrichia_buccalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptotrichia_buccalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["523794"]),
        None,
        Some("."),
        Some("Lebu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloferax mediterranei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "523841.HFX_0001";
/// let this_library_node_name2 = "523841.HFX_3032";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloferax_mediterranei_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloferax_mediterranei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloferax_mediterranei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloferax_mediterranei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["523841"]),
        None,
        Some("."),
        Some("HFX_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanothermococcus thermolithotrophicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "523845.AQXV01000001_gene1042";
/// let this_library_node_name2 = "523845.AQXV01000055_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanothermococcus_thermolithotrophicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanothermococcus_thermolithotrophicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanothermococcus_thermolithotrophicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanothermococcus_thermolithotrophicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["523845"]),
        None,
        Some("."),
        Some("AQXV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermococcus onnurineus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "523850.TON_0001";
/// let this_library_node_name2 = "523850.TON_1976";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermococcus_onnurineus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermococcus_onnurineus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermococcus_onnurineus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermococcus_onnurineus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["523850"]),
        None,
        Some("."),
        Some("TON_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio desulfuricans ATCC27774 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525146.Ddes_0001";
/// let this_library_node_name2 = "525146.Ddes_2382";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_desulfuricans_atcc27774_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_desulfuricans_atcc27774_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_desulfuricans_atcc27774_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_desulfuricans_atcc27774_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525146"]),
        None,
        Some("."),
        Some("Ddes_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. ATCC27244 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525244.HMPREF0023_0001";
/// let this_library_node_name2 = "525244.HMPREF0023_3327";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_atcc27244_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_atcc27244_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_atcc27244_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_atcc27244_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525244"]),
        None,
        Some("."),
        Some("HMPREF0023_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces coleocanis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525245.HMPREF0044_0001";
/// let this_library_node_name2 = "525245.HMPREF0044_1546";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_coleocanis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_coleocanis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_coleocanis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_coleocanis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525245"]),
        None,
        Some("."),
        Some("HMPREF0044_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces urogenitalis DSM15434 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525246.HMPREF0058_0001";
/// let this_library_node_name2 = "525246.HMPREF0058_2403";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_urogenitalis_dsm15434_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_urogenitalis_dsm15434_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_urogenitalis_dsm15434_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_urogenitalis_dsm15434_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525246"]),
        None,
        Some("."),
        Some("HMPREF0058_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerococcus lactolyticus ATCC51172 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525254.HMPREF0072_0001";
/// let this_library_node_name2 = "525254.HMPREF0072_2253";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerococcus_lactolyticus_atcc51172_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerococcus_lactolyticus_atcc51172_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerococcus_lactolyticus_atcc51172_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerococcus_lactolyticus_atcc51172_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525254"]),
        None,
        Some("."),
        Some("HMPREF0072_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerococcus tetradius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525255.HMPREF0077_0001";
/// let this_library_node_name2 = "525255.HMPREF0077_2081";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerococcus_tetradius_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerococcus_tetradius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerococcus_tetradius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerococcus_tetradius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525255"]),
        None,
        Some("."),
        Some("HMPREF0077_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atopobium vaginae DSM15829 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525256.HMPREF0091_10001";
/// let this_library_node_name2 = "525256.HMPREF0091_11244";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atopobium_vaginae_dsm15829_node_name(this_library_node_name1));
/// assert!(is_valid_string_atopobium_vaginae_dsm15829_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atopobium_vaginae_dsm15829_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atopobium_vaginae_dsm15829_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525256"]),
        None,
        Some("."),
        Some("HMPREF0091_1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium gleum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525257.HMPREF0204_10001";
/// let this_library_node_name2 = "525257.HMPREF0204_15290";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_gleum_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_gleum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_gleum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_gleum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525257"]),
        None,
        Some("."),
        Some("HMPREF0204_1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium accolens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525260.HMPREF0276_0001";
/// let this_library_node_name2 = "525260.HMPREF0276_2333";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_accolens_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_accolens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_accolens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_accolens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525260"]),
        None,
        Some("."),
        Some("HMPREF0276_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium lipophiloflavum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525263.HMPREF0298_0001";
/// let this_library_node_name2 = "525263.HMPREF0298_2371";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_lipophiloflavum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_lipophiloflavum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_lipophiloflavum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_lipophiloflavum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525263"]),
        None,
        Some("."),
        Some("HMPREF0298_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium pseudogenitalium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525264.HMPREF0305_10001";
/// let this_library_node_name2 = "525264.HMPREF0305_12493";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_pseudogenitalium_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_pseudogenitalium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_pseudogenitalium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_pseudogenitalium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525264"]),
        None,
        Some("."),
        Some("HMPREF0305_1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium striatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525268.HMPREF0308_0001";
/// let this_library_node_name2 = "525268.HMPREF0308_2677";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_striatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_striatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_striatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_striatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525268"]),
        None,
        Some("."),
        Some("HMPREF0308_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Finegoldia magna ATCC53516 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525282.HMPREF0391_10001";
/// let this_library_node_name2 = "525282.HMPREF0391_11838";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_finegoldia_magna_atcc53516_node_name(this_library_node_name1));
/// assert!(is_valid_string_finegoldia_magna_atcc53516_node_name(this_library_node_name2));
/// assert!(!is_valid_string_finegoldia_magna_atcc53516_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_finegoldia_magna_atcc53516_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525282"]),
        None,
        Some("."),
        Some("HMPREF0391_1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus antri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525309.HMPREF0494_0001";
/// let this_library_node_name2 = "525309.HMPREF0494_2224";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_antri_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_antri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_antri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_antri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525309"]),
        None,
        Some("."),
        Some("HMPREF0494_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus buchneri ATCC11577 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525318.HMPREF0497_0001";
/// let this_library_node_name2 = "525318.HMPREF0497_3002";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_buchneri_atcc11577_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_buchneri_atcc11577_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_buchneri_atcc11577_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_buchneri_atcc11577_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525318"]),
        None,
        Some("."),
        Some("HMPREF0497_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus ultunensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525365.HMPREF0548_0001";
/// let this_library_node_name2 = "525365.HMPREF0548_2210";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_ultunensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_ultunensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_ultunensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_ultunensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525365"]),
        None,
        Some("."),
        Some("HMPREF0548_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeria grayi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525367.HMPREF0556_10001";
/// let this_library_node_name2 = "525367.HMPREF0556_plasmid12625";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeria_grayi_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeria_grayi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeria_grayi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeria_grayi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525367"]),
        None,
        Some("."),
        Some("HMPREF0556_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium parascrofulaceum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525368.HMPREF0591_0001";
/// let this_library_node_name2 = "525368.HMPREF0591_6456";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_parascrofulaceum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_parascrofulaceum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_parascrofulaceum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_parascrofulaceum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525368"]),
        None,
        Some("."),
        Some("HMPREF0591_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobacterium spiritivorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525373.HMPREF0766_10001";
/// let this_library_node_name2 = "525373.HMPREF0766_14472";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobacterium_spiritivorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobacterium_spiritivorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobacterium_spiritivorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobacterium_spiritivorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525373"]),
        None,
        Some("."),
        Some("HMPREF0766_1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus caprae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525378.HMPREF0793_0001";
/// let this_library_node_name2 = "525378.HMPREF0793_2563";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_caprae_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_caprae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_caprae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_caprae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525378"]),
        None,
        Some("."),
        Some("HMPREF0793_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus equinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525379.HMPREF0819_0001";
/// let this_library_node_name2 = "525379.HMPREF0819_1793";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_equinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_equinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_equinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_equinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525379"]),
        None,
        Some("."),
        Some("HMPREF0819_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfomicrobium baculatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525897.Dbac_0001";
/// let this_library_node_name2 = "525897.Dbac_3494";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfomicrobium_baculatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfomicrobium_baculatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfomicrobium_baculatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfomicrobium_baculatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525897"]),
        None,
        Some("."),
        Some("Dbac_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurospirillum deleyianum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525898.Sdel_0001";
/// let this_library_node_name2 = "525898.Sdel_2291";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurospirillum_deleyianum_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurospirillum_deleyianum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurospirillum_deleyianum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurospirillum_deleyianum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525898"]),
        None,
        Some("."),
        Some("Sdel_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermanaerovibrio acidaminovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525903.Taci_0001";
/// let this_library_node_name2 = "525903.Taci_1765";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermanaerovibrio_acidaminovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermanaerovibrio_acidaminovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermanaerovibrio_acidaminovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermanaerovibrio_acidaminovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525903"]),
        None,
        Some("."),
        Some("Taci_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermobaculum terrenum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525904.Tter_0001";
/// let this_library_node_name2 = "525904.Tter_2873";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermobaculum_terrenum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermobaculum_terrenum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermobaculum_terrenum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermobaculum_terrenum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525904"]),
        None,
        Some("."),
        Some("Tter_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidimicrobium ferrooxidans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525909.Afer_0001";
/// let this_library_node_name2 = "525909.Afer_2038";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidimicrobium_ferrooxidans_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidimicrobium_ferrooxidans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidimicrobium_ferrooxidans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidimicrobium_ferrooxidans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525909"]),
        None,
        Some("."),
        Some("Afer_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerococcus prevotii DSM20548 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "525919.Apre_0001";
/// let this_library_node_name2 = "525919.Apre_1852";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerococcus_prevotii_dsm20548_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerococcus_prevotii_dsm20548_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerococcus_prevotii_dsm20548_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerococcus_prevotii_dsm20548_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["525919"]),
        None,
        Some("."),
        Some("Apre_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sebaldella termitidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "526218.Sterm_0001";
/// let this_library_node_name2 = "526218.Sterm_4210";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sebaldella_termitidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sebaldella_termitidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sebaldella_termitidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sebaldella_termitidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["526218"]),
        None,
        Some("."),
        Some("Sterm_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio salexigens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "526222.Desal_0001";
/// let this_library_node_name2 = "526222.Desal_3834";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_salexigens_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_salexigens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_salexigens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_salexigens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["526222"]),
        None,
        Some("."),
        Some("Desal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachyspira murdochii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "526224.Bmur_0001";
/// let this_library_node_name2 = "526224.Bmur_2853";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachyspira_murdochii_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachyspira_murdochii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachyspira_murdochii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachyspira_murdochii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["526224"]),
        None,
        Some("."),
        Some("Bmur_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geodermatophilus obscurus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "526225.Gobs_0001";
/// let this_library_node_name2 = "526225.Gobs_5096";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geodermatophilus_obscurus_node_name(this_library_node_name1));
/// assert!(is_valid_string_geodermatophilus_obscurus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geodermatophilus_obscurus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geodermatophilus_obscurus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["526225"]),
        None,
        Some("."),
        Some("Gobs_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia bronchialis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "526226.Gbro_0001";
/// let this_library_node_name2 = "526226.Gbro_4944";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_bronchialis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_bronchialis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_bronchialis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_bronchialis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["526226"]),
        None,
        Some("."),
        Some("Gbro_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Meiothermus silvanus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "526227.Mesil_0001";
/// let this_library_node_name2 = "526227.Mesil_R0028";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_meiothermus_silvanus_node_name(this_library_node_name1));
/// assert!(is_valid_string_meiothermus_silvanus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_meiothermus_silvanus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_meiothermus_silvanus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["526227"]),
        None,
        Some("."),
        Some("Mesil_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yersinia aldovae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "527002.yaldo0001_10";
/// let this_library_node_name2 = "527002.yaldo0001_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yersinia_aldovae_node_name(this_library_node_name1));
/// assert!(is_valid_string_yersinia_aldovae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yersinia_aldovae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yersinia_aldovae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["527002"]),
        None,
        Some("."),
        Some("yaldo0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Proteus mirabilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "529507.PMI0001";
/// let this_library_node_name2 = "529507.PMIP53";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_proteus_mirabilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_proteus_mirabilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_proteus_mirabilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_proteus_mirabilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["529507"]),
        None,
        Some("."),
        Some("PMI"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrococcus yayanosii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "529709.PYCH_00010";
/// let this_library_node_name2 = "529709.PYCH_19250";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrococcus_yayanosii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrococcus_yayanosii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrococcus_yayanosii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrococcus_yayanosii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["529709"]),
        None,
        Some("."),
        Some("PYCH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thecamonas trahens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "529818.AMSG_00001T0";
/// let this_library_node_name2 = "529818.AMSG_12464T0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thecamonas_trahens_node_name(this_library_node_name1));
/// assert!(is_valid_string_thecamonas_trahens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thecamonas_trahens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thecamonas_trahens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["529818"]),
        None,
        Some("."),
        Some("AMSG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodoluna lacicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "529884.Rhola_00000010";
/// let this_library_node_name2 = "529884.Rhola_00014080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodoluna_lacicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodoluna_lacicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodoluna_lacicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodoluna_lacicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["529884"]),
        None,
        Some("."),
        Some("Rhola_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pirellula staleyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "530564.Psta_0001";
/// let this_library_node_name2 = "530564.Psta_4773";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pirellula_staleyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_pirellula_staleyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pirellula_staleyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pirellula_staleyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["530564"]),
        None,
        Some("."),
        Some("Psta_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacteriaceae bacterium 351910 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "531844.FIC_00001";
/// let this_library_node_name2 = "531844.FIC_02582";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacteriaceae_bacterium_351910_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacteriaceae_bacterium_351910_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacteriaceae_bacterium_351910_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacteriaceae_bacterium_351910_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["531844"]),
        None,
        Some("."),
        Some("FIC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cylindrospermopsis raciborskii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "533240.CRC_00001";
/// let this_library_node_name2 = "533240.CRC_03503";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cylindrospermopsis_raciborskii_node_name(this_library_node_name1));
/// assert!(is_valid_string_cylindrospermopsis_raciborskii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cylindrospermopsis_raciborskii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cylindrospermopsis_raciborskii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["533240"]),
        None,
        Some("."),
        Some("CRC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Raphidiopsis brookii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "533247.CRD_00001";
/// let this_library_node_name2 = "533247.CRD_03062";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_raphidiopsis_brookii_node_name(this_library_node_name1));
/// assert!(is_valid_string_raphidiopsis_brookii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_raphidiopsis_brookii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_raphidiopsis_brookii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["533247"]),
        None,
        Some("."),
        Some("CRD_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidovorax ebreus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "535289.Dtpsy_0001";
/// let this_library_node_name2 = "535289.Dtpsy_3545";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidovorax_ebreus_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidovorax_ebreus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidovorax_ebreus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidovorax_ebreus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["535289"]),
        None,
        Some("."),
        Some("Dtpsy_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium opportunistum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "536019.Mesop_0001";
/// let this_library_node_name2 = "536019.Mesop_R0036";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_opportunistum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_opportunistum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_opportunistum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_opportunistum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["536019"]),
        None,
        Some("."),
        Some("Mesop_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium carboxidivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "536227.CcarbDRAFT_0001";
/// let this_library_node_name2 = "536227.CcarbDRAFT_5462";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_carboxidivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_carboxidivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_carboxidivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_carboxidivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["536227"]),
        None,
        Some("."),
        Some("CcarbDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium botulinum A2 Kyoto nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "536232.CLM_0001";
/// let this_library_node_name2 = "536232.CLM_4153";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_botulinum_a2_kyoto_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_botulinum_a2_kyoto_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_botulinum_a2_kyoto_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_botulinum_a2_kyoto_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["536232"]),
        None,
        Some("."),
        Some("CLM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium botulinum E1 BoNT nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "536233.CLO_0002";
/// let this_library_node_name2 = "536233.CLO_3905";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_botulinum_e1_bont_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_botulinum_e1_bont_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_botulinum_e1_bont_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_botulinum_e1_bont_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["536233"]),
        None,
        Some("."),
        Some("CLO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blautia hansenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "537007.BLAHAN_04000";
/// let this_library_node_name2 = "537007.BLAHAN_07250";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blautia_hansenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_blautia_hansenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blautia_hansenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blautia_hansenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["537007"]),
        None,
        Some("."),
        Some("BLAHAN_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella copri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "537011.PREVCOP_03500";
/// let this_library_node_name2 = "537011.PREVCOP_06914";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_copri_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_copri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_copri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_copri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["537011"]),
        None,
        Some("."),
        Some("PREVCOP_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium methylpentosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "537013.CLOSTMETH_00001";
/// let this_library_node_name2 = "537013.CLOSTMETH_03965";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_methylpentosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_methylpentosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_methylpentosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_methylpentosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["537013"]),
        None,
        Some("."),
        Some("CLOSTMETH_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Liberibacter asiaticus psy62 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "537021.CLIBASIA_00005";
/// let this_library_node_name2 = "537021.CLIBASIA_05675";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_liberibacter_asiaticus_psy62_node_name(this_library_node_name1));
/// assert!(is_valid_string_liberibacter_asiaticus_psy62_node_name(this_library_node_name2));
/// assert!(!is_valid_string_liberibacter_asiaticus_psy62_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_liberibacter_asiaticus_psy62_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["537021"]),
        None,
        Some("."),
        Some("CLIBASIA_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter canadensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "537970.HCAN_0001";
/// let this_library_node_name2 = "537970.HCAN_1557";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_canadensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_canadensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_canadensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_canadensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["537970"]),
        None,
        Some("."),
        Some("HCAN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter cinaedi CCUG18818 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "537971.HCCG_00001";
/// let this_library_node_name2 = "537971.HCCG_02376";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_cinaedi_ccug18818_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_cinaedi_ccug18818_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_cinaedi_ccug18818_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_cinaedi_ccug18818_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["537971"]),
        None,
        Some("."),
        Some("HCCG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter pullorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "537972.ABQU01000001_gene371";
/// let this_library_node_name2 = "537972.ABQU01000131_gene1804";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_pullorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_pullorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_pullorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_pullorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["537972"]),
        None,
        Some("."),
        Some("ABQU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloterrigena turkmenica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "543526.Htur_0001";
/// let this_library_node_name2 = "543526.Htur_5265";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloterrigena_turkmenica_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloterrigena_turkmenica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloterrigena_turkmenica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloterrigena_turkmenica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["543526"]),
        None,
        Some("."),
        Some("Htur_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinoplanes subtropicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "543632.JOJL01000001_gene7525";
/// let this_library_node_name2 = "543632.JOJL01000216_gene184";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinoplanes_subtropicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinoplanes_subtropicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinoplanes_subtropicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinoplanes_subtropicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["543632"]),
        None,
        Some("."),
        Some("JOJL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Variovorax paradoxus S110 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "543728.Vapar_0001";
/// let this_library_node_name2 = "543728.Vapar_6382";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_variovorax_paradoxus_s110_node_name(this_library_node_name1));
/// assert!(is_valid_string_variovorax_paradoxus_s110_node_name(this_library_node_name2));
/// assert!(!is_valid_string_variovorax_paradoxus_s110_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_variovorax_paradoxus_s110_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["543728"]),
        None,
        Some("."),
        Some("Vapar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus casei BL23 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "543734.LCABL_00010";
/// let this_library_node_name2 = "543734.LCABL_31270";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_casei_bl23_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_casei_bl23_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_casei_bl23_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_casei_bl23_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["543734"]),
        None,
        Some("."),
        Some("LCABL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING beta proteobacterium CB nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "543913.D521_0001";
/// let this_library_node_name2 = "543913.D521_2119";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_beta_proteobacterium_cb_node_name(this_library_node_name1));
/// assert!(is_valid_string_beta_proteobacterium_cb_node_name(this_library_node_name2));
/// assert!(!is_valid_string_beta_proteobacterium_cb_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_beta_proteobacterium_cb_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["543913"]),
        None,
        Some("."),
        Some("D521_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium arbusti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "545243.BAEV01000001_gene3125";
/// let this_library_node_name2 = "545243.BAEV01000240_gene350";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_arbusti_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_arbusti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_arbusti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_arbusti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["545243"]),
        None,
        Some("."),
        Some("BAEV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. AKL11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "545264.KB898744_gene1885";
/// let this_library_node_name2 = "545264.KB898763_gene659";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_akl11_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_akl11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_akl11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_akl11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["545264"]),
        None,
        Some("."),
        Some("KB8987"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALJ24 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "545276.KB898724_gene1721";
/// let this_library_node_name2 = "545276.KB898743_gene2561";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_alj24_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_alj24_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_alj24_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_alj24_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["545276"]),
        None,
        Some("."),
        Some("KB8987"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus megaterium QM B1551 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "545693.BMQ_0001";
/// let this_library_node_name2 = "545693.BMQ_5284";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_megaterium_qm_b1551_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_megaterium_qm_b1551_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_megaterium_qm_b1551_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_megaterium_qm_b1551_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["545693"]),
        None,
        Some("."),
        Some("BMQ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema primitia ZAS2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "545694.TREPR_0001";
/// let this_library_node_name2 = "545694.TREPR_3895";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_primitia_zas2_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_primitia_zas2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_primitia_zas2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_primitia_zas2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["545694"]),
        None,
        Some("."),
        Some("TREPR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema azotonutricium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "545695.TREAZ_0001";
/// let this_library_node_name2 = "545695.TREAZ_3666";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_azotonutricium_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_azotonutricium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_azotonutricium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_azotonutricium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["545695"]),
        None,
        Some("."),
        Some("TREAZ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Holdemania filiformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "545696.HOLDEFILI_00001";
/// let this_library_node_name2 = "545696.HOLDEFILI_04275";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_holdemania_filiformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_holdemania_filiformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_holdemania_filiformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_holdemania_filiformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["545696"]),
        None,
        Some("."),
        Some("HOLDEFILI_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium celatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "545697.HMPREF0216_00001";
/// let this_library_node_name2 = "545697.HMPREF0216_03482";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_celatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_celatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_celatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_celatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["545697"]),
        None,
        Some("."),
        Some("HMPREF0216_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria cinerea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546262.NEICINOT_03000";
/// let this_library_node_name2 = "546262.NEICINOT_05190";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_cinerea_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_cinerea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_cinerea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_cinerea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546262"]),
        None,
        Some("."),
        Some("NEICINOT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria flavescens NRL30031H210 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546264.NEIFLAOT_00001";
/// let this_library_node_name2 = "546264.NEIFLAOT_02595";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_flavescens_nrl30031h210_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_flavescens_nrl30031h210_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_flavescens_nrl30031h210_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_flavescens_nrl30031h210_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546264"]),
        None,
        Some("."),
        Some("NEIFLAOT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria mucosa ATCC25996 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546266.NEIMUCOT_03500";
/// let this_library_node_name2 = "546266.NEIMUCOT_06710";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_mucosa_atcc25996_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_mucosa_atcc25996_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_mucosa_atcc25996_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_mucosa_atcc25996_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546266"]),
        None,
        Some("."),
        Some("NEIMUCOT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria polysaccharea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546267.NEIPOLOT_00001";
/// let this_library_node_name2 = "546267.NEIPOLOT_02635";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_polysaccharea_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_polysaccharea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_polysaccharea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_polysaccharea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546267"]),
        None,
        Some("."),
        Some("NEIPOLOT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria subflava nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546268.NEISUBOT_03000";
/// let this_library_node_name2 = "546268.NEISUBOT_05680";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_subflava_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_subflava_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_subflava_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_subflava_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546268"]),
        None,
        Some("."),
        Some("NEISUBOT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Filifactor alocis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546269.HMPREF0389_00001";
/// let this_library_node_name2 = "546269.HMPREF0389_01751";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_filifactor_alocis_node_name(this_library_node_name1));
/// assert!(is_valid_string_filifactor_alocis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_filifactor_alocis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_filifactor_alocis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546269"]),
        None,
        Some("."),
        Some("HMPREF0389_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemella haemolysans ATCC10379 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546270.GEMHA0001_0001";
/// let this_library_node_name2 = "546270.GEMHA0001_1787";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemella_haemolysans_atcc10379_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemella_haemolysans_atcc10379_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemella_haemolysans_atcc10379_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemella_haemolysans_atcc10379_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546270"]),
        None,
        Some("."),
        Some("GEMHA0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas sputigena nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546271.Selsp_0001";
/// let this_library_node_name2 = "546271.Selsp_R0032";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_sputigena_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_sputigena_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_sputigena_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_sputigena_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546271"]),
        None,
        Some("."),
        Some("Selsp_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Veillonella dispar nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546273.VEIDISOL_00001";
/// let this_library_node_name2 = "546273.VEIDISOL_02018";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_veillonella_dispar_node_name(this_library_node_name1));
/// assert!(is_valid_string_veillonella_dispar_node_name(this_library_node_name2));
/// assert!(!is_valid_string_veillonella_dispar_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_veillonella_dispar_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546273"]),
        None,
        Some("."),
        Some("VEIDISOL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eikenella corrodens ATCC23834 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546274.EIKCOROL_00001";
/// let this_library_node_name2 = "546274.EIKCOROL_02679";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eikenella_corrodens_atcc23834_node_name(this_library_node_name1));
/// assert!(is_valid_string_eikenella_corrodens_atcc23834_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eikenella_corrodens_atcc23834_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eikenella_corrodens_atcc23834_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546274"]),
        None,
        Some("."),
        Some("EIKCOROL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium periodonticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546275.FUSPEROL_00004";
/// let this_library_node_name2 = "546275.FUSPEROL_02629";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_periodonticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_periodonticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_periodonticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_periodonticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546275"]),
        None,
        Some("."),
        Some("FUSPEROL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus deserti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "546414.Deide_00010";
/// let this_library_node_name2 = "546414.Deide_23520";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_deserti_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_deserti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_deserti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_deserti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["546414"]),
        None,
        Some("."),
        Some("Deide_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides coprophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "547042.BACCOPRO_00001";
/// let this_library_node_name2 = "547042.BACCOPRO_03906";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_coprophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_coprophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_coprophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_coprophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["547042"]),
        None,
        Some("."),
        Some("BACCOPRO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium pseudocatenulatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "547043.BIFPSEUDO_02300";
/// let this_library_node_name2 = "547043.BIFPSEUDO_04518";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_pseudocatenulatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_pseudocatenulatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_pseudocatenulatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_pseudocatenulatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["547043"]),
        None,
        Some("."),
        Some("BIFPSEUDO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria sicca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "547045.NEISICOT_00001";
/// let this_library_node_name2 = "547045.NEISICOT_03718";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_sicca_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_sicca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_sicca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_sicca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["547045"]),
        None,
        Some("."),
        Some("NEISICOT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hydrogenobaculum sp. HO nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "547144.HydHO_0001";
/// let this_library_node_name2 = "547144.HydHO_R0005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hydrogenobaculum_sp_ho_node_name(this_library_node_name1));
/// assert!(is_valid_string_hydrogenobaculum_sp_ho_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hydrogenobaculum_sp_ho_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hydrogenobaculum_sp_ho_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["547144"]),
        None,
        Some("."),
        Some("HydHO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium vulneris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "547163.BN979_00001";
/// let this_library_node_name2 = "547163.BN979_06737";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_vulneris_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_vulneris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_vulneris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_vulneris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["547163"]),
        None,
        Some("."),
        Some("BN979_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natrialba magadii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "547559.Nmag_0001";
/// let this_library_node_name2 = "547559.Nmag_4210";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natrialba_magadii_node_name(this_library_node_name1));
/// assert!(is_valid_string_natrialba_magadii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natrialba_magadii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natrialba_magadii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["547559"]),
        None,
        Some("."),
        Some("Nmag_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium aurimucosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "548476.189406383";
/// let this_library_node_name2 = "548476.cauri_2539";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_aurimucosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_aurimucosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_aurimucosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_aurimucosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["548476"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium glucuronolyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "548477.HMPREF0294_0001";
/// let this_library_node_name2 = "548477.HMPREF0294_2645";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_glucuronolyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_glucuronolyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_glucuronolyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_glucuronolyticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["548477"]),
        None,
        Some("."),
        Some("HMPREF0294_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mobiluncus curtisii ATCC43063 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "548479.HMPREF0573_10001";
/// let this_library_node_name2 = "548479.HMPREF0573_11909";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mobiluncus_curtisii_atcc43063_node_name(this_library_node_name1));
/// assert!(is_valid_string_mobiluncus_curtisii_atcc43063_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mobiluncus_curtisii_atcc43063_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mobiluncus_curtisii_atcc43063_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["548479"]),
        None,
        Some("."),
        Some("HMPREF0573_1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ferrimonas balearica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "550540.Fbal_0001";
/// let this_library_node_name2 = "550540.Fbal_3803";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ferrimonas_balearica_node_name(this_library_node_name1));
/// assert!(is_valid_string_ferrimonas_balearica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ferrimonas_balearica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ferrimonas_balearica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["550540"]),
        None,
        Some("."),
        Some("Fbal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nostoc azollae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "551115.Aazo_0002";
/// let this_library_node_name2 = "551115.Aazo_5357";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nostoc_azollae_node_name(this_library_node_name1));
/// assert!(is_valid_string_nostoc_azollae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nostoc_azollae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nostoc_azollae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["551115"]),
        None,
        Some("."),
        Some("Aazo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hirschia maritima nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "551275.KB899544_gene1000";
/// let this_library_node_name2 = "551275.KB899553_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hirschia_maritima_node_name(this_library_node_name1));
/// assert!(is_valid_string_hirschia_maritima_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hirschia_maritima_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hirschia_maritima_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["551275"]),
        None,
        Some("."),
        Some("KB8995"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ponticaulis koreensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "551789.ATVJ01000001_gene1000";
/// let this_library_node_name2 = "551789.ATVJ01000004_gene430";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ponticaulis_koreensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ponticaulis_koreensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ponticaulis_koreensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ponticaulis_koreensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["551789"]),
        None,
        Some("."),
        Some("ATVJ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erysipelotrichaceae bacterium 5254FAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "552396.HMPREF0863_00001";
/// let this_library_node_name2 = "552396.HMPREF0863_04240";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erysipelotrichaceae_bacterium_5254faa_node_name(this_library_node_name1));
/// assert!(is_valid_string_erysipelotrichaceae_bacterium_5254faa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erysipelotrichaceae_bacterium_5254faa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erysipelotrichaceae_bacterium_5254faa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["552396"]),
        None,
        Some("."),
        Some("HMPREF0863_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcaceae bacterium D16 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "552398.HMPREF0866_00006";
/// let this_library_node_name2 = "552398.HMPREF0866_04605";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcaceae_bacterium_d16_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcaceae_bacterium_d16_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcaceae_bacterium_d16_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcaceae_bacterium_d16_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["552398"]),
        None,
        Some("."),
        Some("HMPREF0866_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cryptococcus gattii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "552467.XP_003191087.1";
/// let this_library_node_name2 = "552467.XP_003197651.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cryptococcus_gattii_node_name(this_library_node_name1));
/// assert!(is_valid_string_cryptococcus_gattii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cryptococcus_gattii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cryptococcus_gattii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["552467"]),
        None,
        Some("."),
        Some("XP_00319"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium animalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "552531.BIF_00002";
/// let this_library_node_name2 = "552531.BIF_02268";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_animalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_animalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_animalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_animalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["552531"]),
        None,
        Some("."),
        Some("BIF_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dehalogenimonas lykanthroporepellens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "552811.Dehly_0001";
/// let this_library_node_name2 = "552811.Dehly_1722";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dehalogenimonas_lykanthroporepellens_node_name(this_library_node_name1));
/// assert!(is_valid_string_dehalogenimonas_lykanthroporepellens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dehalogenimonas_lykanthroporepellens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dehalogenimonas_lykanthroporepellens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["552811"]),
        None,
        Some("."),
        Some("Dehly_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella bivia JCVIHMP010 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553171.HMPREF0648_0001";
/// let this_library_node_name2 = "553171.HMPREF0648_2102";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_bivia_jcvihmp010_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_bivia_jcvihmp010_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_bivia_jcvihmp010_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_bivia_jcvihmp010_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553171"]),
        None,
        Some("."),
        Some("HMPREF0648_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella melaninogenica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553174.HMPREF0659_A5000";
/// let this_library_node_name2 = "553174.HMPREF0659_A7408";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_melaninogenica_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_melaninogenica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_melaninogenica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_melaninogenica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553174"]),
        None,
        Some("."),
        Some("HMPREF0659_A"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas endodontalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553175.POREN0001_0001";
/// let this_library_node_name2 = "553175.POREN0001_2028";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_endodontalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_endodontalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_endodontalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_endodontalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553175"]),
        None,
        Some("."),
        Some("POREN0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga sputigena nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553177.CAPSP0001_0001";
/// let this_library_node_name2 = "553177.CAPSP0001_2846";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_sputigena_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_sputigena_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_sputigena_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_sputigena_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553177"]),
        None,
        Some("."),
        Some("CAPSP0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga gingivalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553178.CAPGI0001_0001";
/// let this_library_node_name2 = "553178.CAPGI0001_2647";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_gingivalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_gingivalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_gingivalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_gingivalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553178"]),
        None,
        Some("."),
        Some("CAPGI0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atopobium rimae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553184.ATORI0001_0001";
/// let this_library_node_name2 = "553184.ATORI0001_1605";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atopobium_rimae_node_name(this_library_node_name1));
/// assert!(is_valid_string_atopobium_rimae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atopobium_rimae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atopobium_rimae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553184"]),
        None,
        Some("."),
        Some("ATORI0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium amycolatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553204.CORAM0001_0001";
/// let this_library_node_name2 = "553204.CORAM0001_2248";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_amycolatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_amycolatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_amycolatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_amycolatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553204"]),
        None,
        Some("."),
        Some("CORAM0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium matruchotii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553207.HMPREF0299_5000";
/// let this_library_node_name2 = "553207.HMPREF0299_7684";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_matruchotii_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_matruchotii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_matruchotii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_matruchotii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553207"]),
        None,
        Some("."),
        Some("HMPREF0299_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enhydrobacter aerosaccus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553217.ENHAE0001_0001";
/// let this_library_node_name2 = "553217.ENHAE0001_2622";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enhydrobacter_aerosaccus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enhydrobacter_aerosaccus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enhydrobacter_aerosaccus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enhydrobacter_aerosaccus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553217"]),
        None,
        Some("."),
        Some("ENHAE0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter rectus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553218.CAMRE0001_0001";
/// let this_library_node_name2 = "553218.CAMRE0001_3307";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_rectus_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_rectus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_rectus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_rectus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553218"]),
        None,
        Some("."),
        Some("CAMRE0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter showae RM3277 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553219.CAMSH0001_0001";
/// let this_library_node_name2 = "553219.CAMSH0001_2405";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_showae_rm3277_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_showae_rm3277_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_showae_rm3277_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_showae_rm3277_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553219"]),
        None,
        Some("."),
        Some("CAMSH0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter gracilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553220.CAMGR0001_0001";
/// let this_library_node_name2 = "553220.CAMGR0001_2893";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_gracilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_gracilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_gracilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_gracilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553220"]),
        None,
        Some("."),
        Some("CAMGR0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cobetia crustatorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553385.JEMF01000001_gene549";
/// let this_library_node_name2 = "553385.JEMF01000138_gene2521";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cobetia_crustatorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_cobetia_crustatorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cobetia_crustatorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cobetia_crustatorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553385"]),
        None,
        Some("."),
        Some("JEMF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium hylemonae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "553973.CLOHYLEM_03900";
/// let this_library_node_name2 = "553973.CLOHYLEM_07931";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_hylemonae_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_hylemonae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_hylemonae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_hylemonae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["553973"]),
        None,
        Some("."),
        Some("CLOHYLEM_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorella variabilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "554065.XP_005842542.1";
/// let this_library_node_name2 = "554065.XP_005852326.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorella_variabilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorella_variabilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorella_variabilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorella_variabilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["554065"]),
        None,
        Some("."),
        Some("XP_0058"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermosediminibacter oceani nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "555079.Toce_0001";
/// let this_library_node_name2 = "555079.Toce_R0009";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermosediminibacter_oceani_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermosediminibacter_oceani_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermosediminibacter_oceani_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermosediminibacter_oceani_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["555079"]),
        None,
        Some("."),
        Some("Toce_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dethiobacter alkaliphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "555088.DealDRAFT_0001";
/// let this_library_node_name2 = "555088.DealDRAFT_3164";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dethiobacter_alkaliphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_dethiobacter_alkaliphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dethiobacter_alkaliphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dethiobacter_alkaliphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["555088"]),
        None,
        Some("."),
        Some("DealDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zymomonas mobilis ATCC10988 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "555217.Zmob_0001";
/// let this_library_node_name2 = "555217.Zmob_1838";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zymomonas_mobilis_atcc10988_node_name(this_library_node_name1));
/// assert!(is_valid_string_zymomonas_mobilis_atcc10988_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zymomonas_mobilis_atcc10988_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zymomonas_mobilis_atcc10988_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["555217"]),
        None,
        Some("."),
        Some("Zmob_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Galbibacter marinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "555500.I215_00005";
/// let this_library_node_name2 = "555500.I215_15733";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_galbibacter_marinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_galbibacter_marinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_galbibacter_marinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_galbibacter_marinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["555500"]),
        None,
        Some("."),
        Some("I215_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halothiobacillus neapolitanus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "555778.Hneap_0001";
/// let this_library_node_name2 = "555778.Hneap_2414";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halothiobacillus_neapolitanus_node_name(this_library_node_name1));
/// assert!(is_valid_string_halothiobacillus_neapolitanus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halothiobacillus_neapolitanus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halothiobacillus_neapolitanus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["555778"]),
        None,
        Some("."),
        Some("Hneap_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfonatronospira thiodismutans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "555779.Dthio_PD0001";
/// let this_library_node_name2 = "555779.Dthio_PD3853";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfonatronospira_thiodismutans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfonatronospira_thiodismutans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfonatronospira_thiodismutans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfonatronospira_thiodismutans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["555779"]),
        None,
        Some("."),
        Some("Dthio_PD"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novosphingobium sp. Rr 217 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "555793.WSK_0001";
/// let this_library_node_name2 = "555793.WSK_4352";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novosphingobium_sp_rr_217_node_name(this_library_node_name1));
/// assert!(is_valid_string_novosphingobium_sp_rr_217_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novosphingobium_sp_rr_217_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novosphingobium_sp_rr_217_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["555793"]),
        None,
        Some("."),
        Some("WSK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. D5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "556261.HMPREF0240_00001";
/// let this_library_node_name2 = "556261.HMPREF0240_04566";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_d5_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_d5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_d5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_d5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["556261"]),
        None,
        Some("."),
        Some("HMPREF0240_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium necrophorum D12 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "556263.FSEG_00001";
/// let this_library_node_name2 = "556263.FSEG_02259";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_necrophorum_d12_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_necrophorum_d12_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_necrophorum_d12_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_necrophorum_d12_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["556263"]),
        None,
        Some("."),
        Some("FSEG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter winghamensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "556267.HWAG_00001";
/// let this_library_node_name2 = "556267.HWAG_01639";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_winghamensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_winghamensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_winghamensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_winghamensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["556267"]),
        None,
        Some("."),
        Some("HWAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oxalobacter formigenes HOxBLS nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "556268.OFAG_00001";
/// let this_library_node_name2 = "556268.OFAG_02383";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oxalobacter_formigenes_hoxbls_node_name(this_library_node_name1));
/// assert!(is_valid_string_oxalobacter_formigenes_hoxbls_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oxalobacter_formigenes_hoxbls_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oxalobacter_formigenes_hoxbls_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["556268"]),
        None,
        Some("."),
        Some("OFAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oxalobacter formigenes OXCC13 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "556269.ACDQ01000001_gene1174";
/// let this_library_node_name2 = "556269.ACDQ01000027_gene2072";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oxalobacter_formigenes_oxcc13_node_name(this_library_node_name1));
/// assert!(is_valid_string_oxalobacter_formigenes_oxcc13_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oxalobacter_formigenes_oxcc13_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oxalobacter_formigenes_oxcc13_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["556269"]),
        None,
        Some("."),
        Some("ACDQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus reuteri DSM20016 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "557436.Lreu_0001";
/// let this_library_node_name2 = "557436.Lreu_1944";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_reuteri_dsm20016_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_reuteri_dsm20016_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_reuteri_dsm20016_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_reuteri_dsm20016_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["557436"]),
        None,
        Some("."),
        Some("Lreu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Laribacter hongkongensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "557598.LHK_00001";
/// let this_library_node_name2 = "557598.LHK_03257";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_laribacter_hongkongensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_laribacter_hongkongensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_laribacter_hongkongensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_laribacter_hongkongensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["557598"]),
        None,
        Some("."),
        Some("LHK_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium kansasii ATCC12478 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "557599.MKAN_00005";
/// let this_library_node_name2 = "557599.MKAN_29850";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_kansasii_atcc12478_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_kansasii_atcc12478_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_kansasii_atcc12478_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_kansasii_atcc12478_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["557599"]),
        None,
        Some("."),
        Some("MKAN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium piperi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "558152.IQ37_00005";
/// let this_library_node_name2 = "558152.IQ37_19775";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_piperi_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_piperi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_piperi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_piperi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["558152"]),
        None,
        Some("."),
        Some("IQ37_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lentibacillus jeotgali nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "558169.AGAV01000001_gene3259";
/// let this_library_node_name2 = "558169.AGAV01000031_gene3359";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lentibacillus_jeotgali_node_name(this_library_node_name1));
/// assert!(is_valid_string_lentibacillus_jeotgali_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lentibacillus_jeotgali_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lentibacillus_jeotgali_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["558169"]),
        None,
        Some("."),
        Some("AGAV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium doosanense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "558173.CDOO_00005";
/// let this_library_node_name2 = "558173.CDOO_13375";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_doosanense_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_doosanense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_doosanense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_doosanense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["558173"]),
        None,
        Some("."),
        Some("CDOO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aeromonas sp. AE122 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "558884.JRGM01000008_gene3384";
/// let this_library_node_name2 = "558884.JRGM01000191_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aeromonas_sp_ae122_node_name(this_library_node_name1));
/// assert!(is_valid_string_aeromonas_sp_ae122_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aeromonas_sp_ae122_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aeromonas_sp_ae122_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["558884"]),
        None,
        Some("."),
        Some("JRGM01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomadura flavalba nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "561175.KB894093_gene2654";
/// let this_library_node_name2 = "561175.KB894114_gene1402";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomadura_flavalba_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomadura_flavalba_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomadura_flavalba_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomadura_flavalba_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["561175"]),
        None,
        Some("."),
        Some("KB894"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerococcus hydrogenalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "561177.ANHYDRO_00001";
/// let this_library_node_name2 = "561177.ANHYDRO_02126";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerococcus_hydrogenalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerococcus_hydrogenalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerococcus_hydrogenalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerococcus_hydrogenalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["561177"]),
        None,
        Some("."),
        Some("ANHYDRO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium gallicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "561180.BIFGAL_02500";
/// let this_library_node_name2 = "561180.BIFGAL_04479";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_gallicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_gallicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_gallicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_gallicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["561180"]),
        None,
        Some("."),
        Some("BIFGAL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dickeya zeae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "561229.Dd1591_0001";
/// let this_library_node_name2 = "561229.Dd1591_4267";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dickeya_zeae_node_name(this_library_node_name1));
/// assert!(is_valid_string_dickeya_zeae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dickeya_zeae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dickeya_zeae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["561229"]),
        None,
        Some("."),
        Some("Dd1591_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pectobacterium carotovorum PC1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "561230.PC1_0001";
/// let this_library_node_name2 = "561230.PC1_4295";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pectobacterium_carotovorum_pc1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pectobacterium_carotovorum_pc1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pectobacterium_carotovorum_pc1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pectobacterium_carotovorum_pc1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["561230"]),
        None,
        Some("."),
        Some("PC1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pectobacterium wasabiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "561231.Pecwa_0001";
/// let this_library_node_name2 = "561231.Pecwa_4618";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pectobacterium_wasabiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_pectobacterium_wasabiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pectobacterium_wasabiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pectobacterium_wasabiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["561231"]),
        None,
        Some("."),
        Some("Pecwa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amphibacillus jilinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "562743.JH976434_gene1000";
/// let this_library_node_name2 = "562743.JH976450_gene2707";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amphibacillus_jilinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_amphibacillus_jilinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amphibacillus_jilinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amphibacillus_jilinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["562743"]),
        None,
        Some("."),
        Some("JH9764"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kyrpidia tusciae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "562970.Btus_0001";
/// let this_library_node_name2 = "562970.Btus_3323";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kyrpidia_tusciae_node_name(this_library_node_name1));
/// assert!(is_valid_string_kyrpidia_tusciae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kyrpidia_tusciae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kyrpidia_tusciae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["562970"]),
        None,
        Some("."),
        Some("Btus_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces viscosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "562973.HMPREF0059_00001";
/// let this_library_node_name2 = "562973.HMPREF0059_02728";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_viscosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_viscosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_viscosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_viscosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["562973"]),
        None,
        Some("."),
        Some("HMPREF0059_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemella haemolysans M341 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "562981.HMPREF0428_00001";
/// let this_library_node_name2 = "562981.HMPREF0428_01933";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemella_haemolysans_m341_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemella_haemolysans_m341_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemella_haemolysans_m341_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemella_haemolysans_m341_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["562981"]),
        None,
        Some("."),
        Some("HMPREF0428_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemella morbillorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "562982.HMPREF0432_00001";
/// let this_library_node_name2 = "562982.HMPREF0432_01625";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemella_morbillorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemella_morbillorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemella_morbillorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemella_morbillorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["562982"]),
        None,
        Some("."),
        Some("HMPREF0432_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemella sanguinis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "562983.HMPREF0433_00001";
/// let this_library_node_name2 = "562983.HMPREF0433_01881";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemella_sanguinis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemella_sanguinis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemella_sanguinis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemella_sanguinis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["562983"]),
        None,
        Some("."),
        Some("HMPREF0433_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella oris C735 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "563008.HMPREF0665_00001";
/// let this_library_node_name2 = "563008.HMPREF0665_02742";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_oris_c735_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_oris_c735_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_oris_c735_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_oris_c735_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["563008"]),
        None,
        Some("."),
        Some("HMPREF0665_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. C561 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "563031.HMPREF0666_00001";
/// let this_library_node_name2 = "563031.HMPREF0666_03402";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_c561_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_c561_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_c561_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_c561_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["563031"]),
        None,
        Some("."),
        Some("HMPREF0666_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. M143 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "563037.HMPREF0850_00001";
/// let this_library_node_name2 = "563037.HMPREF0850_01802";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_m143_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_m143_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_m143_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_m143_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["563037"]),
        None,
        Some("."),
        Some("HMPREF0850_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. M334 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "563038.HMPREF0851_00001";
/// let this_library_node_name2 = "563038.HMPREF0851_02101";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_m334_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_m334_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_m334_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_m334_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["563038"]),
        None,
        Some("."),
        Some("HMPREF0851_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurimonas autotrophica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "563040.Saut_0001";
/// let this_library_node_name2 = "563040.Saut_2165";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurimonas_autotrophica_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurimonas_autotrophica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurimonas_autotrophica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurimonas_autotrophica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["563040"]),
        None,
        Some("."),
        Some("Saut_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bilophila wadsworthia 316 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "563192.HMPREF0179_00001";
/// let this_library_node_name2 = "563192.HMPREF0179_05331";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bilophila_wadsworthia_316_node_name(this_library_node_name1));
/// assert!(is_valid_string_bilophila_wadsworthia_316_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bilophila_wadsworthia_316_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bilophila_wadsworthia_316_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["563192"]),
        None,
        Some("."),
        Some("HMPREF0179_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geoglobus acetivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "565033.GACE_0002";
/// let this_library_node_name2 = "565033.GACE_2301";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geoglobus_acetivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_geoglobus_acetivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geoglobus_acetivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geoglobus_acetivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["565033"]),
        None,
        Some("."),
        Some("GACE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachyspira hyodysenteriae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "565034.BHWA1_00001";
/// let this_library_node_name2 = "565034.BHWA1_02696";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachyspira_hyodysenteriae_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachyspira_hyodysenteriae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachyspira_hyodysenteriae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachyspira_hyodysenteriae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["565034"]),
        None,
        Some("."),
        Some("BHWA1_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Luminiphilus syltensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "565045.NOR51B_1";
/// let this_library_node_name2 = "565045.NOR51B_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_luminiphilus_syltensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_luminiphilus_syltensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_luminiphilus_syltensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_luminiphilus_syltensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["565045"]),
        None,
        Some("."),
        Some("NOR51B_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ureaplasma urealyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "565575.UUR10_0001";
/// let this_library_node_name2 = "565575.UUR10_0709";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ureaplasma_urealyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_ureaplasma_urealyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ureaplasma_urealyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ureaplasma_urealyticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["565575"]),
        None,
        Some("."),
        Some("UUR10_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus gallinarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "565653.EGBG_00001";
/// let this_library_node_name2 = "565653.EGBG_03041";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_gallinarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_gallinarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_gallinarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_gallinarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["565653"]),
        None,
        Some("."),
        Some("EGBG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus casseliflavus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "565655.ECBG_00001";
/// let this_library_node_name2 = "565655.ECBG_04271";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_casseliflavus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_casseliflavus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_casseliflavus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_casseliflavus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["565655"]),
        None,
        Some("."),
        Some("ECBG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus faecium C68 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "565664.EFXG_00001";
/// let this_library_node_name2 = "565664.EFXG_04119";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_faecium_c68_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_faecium_c68_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_faecium_c68_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_faecium_c68_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["565664"]),
        None,
        Some("."),
        Some("EFXG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces ghanaensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "566461.SSFG_00001";
/// let this_library_node_name2 = "566461.SSFG_07903";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_ghanaensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_ghanaensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_ghanaensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_ghanaensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["566461"]),
        None,
        Some("."),
        Some("SSFG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium NOR53 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "566466.NOR53_1";
/// let this_library_node_name2 = "566466.NOR53_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_nor53_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_nor53_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_nor53_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_nor53_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["566466"]),
        None,
        Some("."),
        Some("NOR53_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium catenulatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "566552.BIFCAT_00001";
/// let this_library_node_name2 = "566552.BIFCAT_02012";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_catenulatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_catenulatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_catenulatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_catenulatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["566552"]),
        None,
        Some("."),
        Some("BIFCAT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Metarhizium robertsii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "568076.XP_007816190.1";
/// let this_library_node_name2 = "568076.XP_007826772.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_metarhizium_robertsii_node_name(this_library_node_name1));
/// assert!(is_valid_string_metarhizium_robertsii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_metarhizium_robertsii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_metarhizium_robertsii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["568076"]),
        None,
        Some("."),
        Some("XP_0078"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus rhamnosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "568703.LGG_00001";
/// let this_library_node_name2 = "568703.LGG_02944";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_rhamnosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_rhamnosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_rhamnosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_rhamnosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["568703"]),
        None,
        Some("."),
        Some("LGG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bordetella pertussis 18323 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "568706.BN118_0001";
/// let this_library_node_name2 = "568706.BN118_3746";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bordetella_pertussis_18323_node_name(this_library_node_name1));
/// assert!(is_valid_string_bordetella_pertussis_18323_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bordetella_pertussis_18323_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bordetella_pertussis_18323_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["568706"]),
        None,
        Some("."),
        Some("BN118_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dickeya sp. NCPPB569 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "568768.CM001975_gene1";
/// let this_library_node_name2 = "568768.CM001975_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dickeya_sp_ncppb569_node_name(this_library_node_name1));
/// assert!(is_valid_string_dickeya_sp_ncppb569_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dickeya_sp_ncppb569_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dickeya_sp_ncppb569_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["568768"]),
        None,
        Some("."),
        Some("CM001975_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidaminococcus intestini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "568816.Acin_0001";
/// let this_library_node_name2 = "568816.Acin_2466";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidaminococcus_intestini_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidaminococcus_intestini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidaminococcus_intestini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidaminococcus_intestini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["568816"]),
        None,
        Some("."),
        Some("Acin_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia symbiotica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "568817.SCc_001";
/// let this_library_node_name2 = "568817.SCc_772";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_symbiotica_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_symbiotica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_symbiotica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_symbiotica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["568817"]),
        None,
        Some("."),
        Some("SCc_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardiopsis potens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "570268.ANBB01000001_gene1242";
/// let this_library_node_name2 = "570268.ANBB01000133_gene3242";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardiopsis_potens_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardiopsis_potens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardiopsis_potens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardiopsis_potens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["570268"]),
        None,
        Some("."),
        Some("ANBB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wolbachia sp. Culex nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "570417.WP0001";
/// let this_library_node_name2 = "570417.WP1387";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wolbachia_sp_culex_node_name(this_library_node_name1));
/// assert!(is_valid_string_wolbachia_sp_culex_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wolbachia_sp_culex_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wolbachia_sp_culex_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["570417"]),
        None,
        Some("."),
        Some("WP"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fodinicurvata sediminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "570952.ATVH01000001_gene872";
/// let this_library_node_name2 = "570952.ATVH01000020_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fodinicurvata_sediminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_fodinicurvata_sediminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fodinicurvata_sediminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fodinicurvata_sediminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["570952"]),
        None,
        Some("."),
        Some("ATVH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fodinicurvata fenggangensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "570967.JMLV01000001_gene2416";
/// let this_library_node_name2 = "570967.JMLV01000037_gene1283";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fodinicurvata_fenggangensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_fodinicurvata_fenggangensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fodinicurvata_fenggangensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fodinicurvata_fenggangensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["570967"]),
        None,
        Some("."),
        Some("JMLV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sedimentitalea nanhaiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "571166.KI421508_gene1";
/// let this_library_node_name2 = "571166.KI421510_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sedimentitalea_nanhaiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sedimentitalea_nanhaiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sedimentitalea_nanhaiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sedimentitalea_nanhaiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["571166"]),
        None,
        Some("."),
        Some("KI4215"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hamiltonella defensa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "572265.HDEF_0001";
/// let this_library_node_name2 = "572265.HDEF_p0058";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hamiltonella_defensa_node_name(this_library_node_name1));
/// assert!(is_valid_string_hamiltonella_defensa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hamiltonella_defensa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hamiltonella_defensa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["572265"]),
        None,
        Some("."),
        Some("HDEF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Allochromatium vinosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "572477.Alvin_0001";
/// let this_library_node_name2 = "572477.Alvin_3302";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_allochromatium_vinosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_allochromatium_vinosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_allochromatium_vinosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_allochromatium_vinosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["572477"]),
        None,
        Some("."),
        Some("Alvin_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vulcanisaeta distributa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "572478.Vdis_0001";
/// let this_library_node_name2 = "572478.Vdis_2544";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vulcanisaeta_distributa_node_name(this_library_node_name1));
/// assert!(is_valid_string_vulcanisaeta_distributa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vulcanisaeta_distributa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vulcanisaeta_distributa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["572478"]),
        None,
        Some("."),
        Some("Vdis_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halanaerobium praevalens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "572479.Hprae_0001";
/// let this_library_node_name2 = "572479.Hprae_R0010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halanaerobium_praevalens_node_name(this_library_node_name1));
/// assert!(is_valid_string_halanaerobium_praevalens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halanaerobium_praevalens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halanaerobium_praevalens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["572479"]),
        None,
        Some("."),
        Some("Hprae_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arcobacter nitrofigilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "572480.Arnit_0001";
/// let this_library_node_name2 = "572480.Arnit_3150";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arcobacter_nitrofigilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_arcobacter_nitrofigilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arcobacter_nitrofigilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arcobacter_nitrofigilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["572480"]),
        None,
        Some("."),
        Some("Arnit_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ilyobacter polytropus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "572544.Ilyop_0001";
/// let this_library_node_name2 = "572544.Ilyop_R0032";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ilyobacter_polytropus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ilyobacter_polytropus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ilyobacter_polytropus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ilyobacter_polytropus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["572544"]),
        None,
        Some("."),
        Some("Ilyop_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Archaeoglobus profundus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "572546.Arcpr_0001";
/// let this_library_node_name2 = "572546.Arcpr_1858";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_archaeoglobus_profundus_node_name(this_library_node_name1));
/// assert!(is_valid_string_archaeoglobus_profundus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_archaeoglobus_profundus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_archaeoglobus_profundus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["572546"]),
        None,
        Some("."),
        Some("Arcpr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aminobacterium colombiense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "572547.Amico_0001";
/// let this_library_node_name2 = "572547.Amico_1914";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aminobacterium_colombiense_node_name(this_library_node_name1));
/// assert!(is_valid_string_aminobacterium_colombiense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aminobacterium_colombiense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aminobacterium_colombiense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["572547"]),
        None,
        Some("."),
        Some("Amico_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium cellulovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "573061.Clocel_0001";
/// let this_library_node_name2 = "573061.Clocel_4389";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_cellulovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_cellulovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_cellulovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_cellulovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["573061"]),
        None,
        Some("."),
        Some("Clocel_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanocaldococcus infernus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "573063.Metin_0001";
/// let this_library_node_name2 = "573063.Metin_1470";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanocaldococcus_infernus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanocaldococcus_infernus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanocaldococcus_infernus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanocaldococcus_infernus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["573063"]),
        None,
        Some("."),
        Some("Metin_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanocaldococcus fervens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "573064.Mefer_0001";
/// let this_library_node_name2 = "573064.Mefer_1620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanocaldococcus_fervens_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanocaldococcus_fervens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanocaldococcus_fervens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanocaldococcus_fervens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["573064"]),
        None,
        Some("."),
        Some("Mefer_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Asticcacaulis excentricus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "573065.Astex_0001";
/// let this_library_node_name2 = "573065.Astex_3705";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_asticcacaulis_excentricus_node_name(this_library_node_name1));
/// assert!(is_valid_string_asticcacaulis_excentricus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_asticcacaulis_excentricus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_asticcacaulis_excentricus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["573065"]),
        None,
        Some("."),
        Some("Astex_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio magneticus RS1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "573370.DMR_00010";
/// let this_library_node_name2 = "573370.DMR_p1_00650";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_magneticus_rs1_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_magneticus_rs1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_magneticus_rs1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_magneticus_rs1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["573370"]),
        None,
        Some("."),
        Some("DMR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirochaeta smaragdinae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "573413.Spirs_0001";
/// let this_library_node_name2 = "573413.Spirs_R0031";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirochaeta_smaragdinae_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirochaeta_smaragdinae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirochaeta_smaragdinae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirochaeta_smaragdinae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["573413"]),
        None,
        Some("."),
        Some("Spirs_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Francisella sp. TX077308 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "573569.F7308_0001";
/// let this_library_node_name2 = "573569.F7308_1980";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_francisella_sp_tx077308_node_name(this_library_node_name1));
/// assert!(is_valid_string_francisella_sp_tx077308_node_name(this_library_node_name2));
/// assert!(!is_valid_string_francisella_sp_tx077308_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_francisella_sp_tx077308_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["573569"]),
        None,
        Some("."),
        Some("F7308_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetohalobium arabaticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "574087.Acear_0001";
/// let this_library_node_name2 = "574087.Acear_2353";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetohalobium_arabaticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetohalobium_arabaticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetohalobium_arabaticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetohalobium_arabaticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["574087"]),
        None,
        Some("."),
        Some("Acear_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus gaemokensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "574375.BAGA_00010";
/// let this_library_node_name2 = "574375.BAGA_29805";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_gaemokensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_gaemokensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_gaemokensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_gaemokensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["574375"]),
        None,
        Some("."),
        Some("BAGA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus manliponensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "574376.BAMA_00005";
/// let this_library_node_name2 = "574376.BAMA_24790";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_manliponensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_manliponensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_manliponensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_manliponensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["574376"]),
        None,
        Some("."),
        Some("BAMA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaplasma centrale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "574556.ACIS_00001";
/// let this_library_node_name2 = "574556.ACIS_01202";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaplasma_centrale_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaplasma_centrale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaplasma_centrale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaplasma_centrale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["574556"]),
        None,
        Some("."),
        Some("ACIS_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas zhanjiangensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "574966.KB898646_gene2769";
/// let this_library_node_name2 = "574966.KB898661_gene2684";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_zhanjiangensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_zhanjiangensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_zhanjiangensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_zhanjiangensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["574966"]),
        None,
        Some("."),
        Some("KB8986"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Isosphaera pallida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575540.Isop_0001";
/// let this_library_node_name2 = "575540.Isop_R0025";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_isosphaera_pallida_node_name(this_library_node_name1));
/// assert!(is_valid_string_isosphaera_pallida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_isosphaera_pallida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_isosphaera_pallida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575540"]),
        None,
        Some("."),
        Some("Isop_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. RUH2624 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575564.HMPREF0014_00001";
/// let this_library_node_name2 = "575564.HMPREF0014_04668";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_ruh2624_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_ruh2624_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_ruh2624_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_ruh2624_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575564"]),
        None,
        Some("."),
        Some("HMPREF0014_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter johnsonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575586.HMPREF0016_00001";
/// let this_library_node_name2 = "575586.HMPREF0016_03363";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_johnsonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_johnsonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_johnsonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_johnsonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575586"]),
        None,
        Some("."),
        Some("HMPREF0016_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter lwoffii SH145 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575588.ACPN01000001_gene1312";
/// let this_library_node_name2 = "575588.ACPN01000249_gene1709";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_lwoffii_sh145_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_lwoffii_sh145_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_lwoffii_sh145_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_lwoffii_sh145_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575588"]),
        None,
        Some("."),
        Some("ACPN01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter radioresistens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575589.HMPREF0018_00001";
/// let this_library_node_name2 = "575589.HMPREF0018_02874";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_radioresistens_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_radioresistens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_radioresistens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_radioresistens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575589"]),
        None,
        Some("."),
        Some("HMPREF0018_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroidetes F0058 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575590.HMPREF0156_00001";
/// let this_library_node_name2 = "575590.HMPREF0156_01876";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroidetes_f0058_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroidetes_f0058_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroidetes_f0058_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroidetes_f0058_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575590"]),
        None,
        Some("."),
        Some("HMPREF0156_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae F0167 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575593.HMPREF0491_00001";
/// let this_library_node_name2 = "575593.HMPREF0491_03094";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_f0167_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_f0167_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_f0167_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_f0167_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575593"]),
        None,
        Some("."),
        Some("HMPREF0491_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus coleohominis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575594.ACOH01000001_gene558";
/// let this_library_node_name2 = "575594.ACOH01000035_gene377";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_coleohominis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_coleohominis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_coleohominis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_coleohominis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575594"]),
        None,
        Some("."),
        Some("ACOH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus jensenii 1153CHN nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575605.ACQN01000001_gene338";
/// let this_library_node_name2 = "575605.ACQN01000058_gene1093";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_jensenii_1153chn_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_jensenii_1153chn_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_jensenii_1153chn_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_jensenii_1153chn_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575605"]),
        None,
        Some("."),
        Some("ACQN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus jensenii 272CHN nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575606.HMPREF0525_00001";
/// let this_library_node_name2 = "575606.HMPREF0525_01565";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_jensenii_272chn_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_jensenii_272chn_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_jensenii_272chn_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_jensenii_272chn_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575606"]),
        None,
        Some("."),
        Some("HMPREF0525_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus sp. F0131 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575609.HMPREF0629_00001";
/// let this_library_node_name2 = "575609.HMPREF0629_01450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_sp_f0131_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_sp_f0131_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_sp_f0131_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_sp_f0131_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575609"]),
        None,
        Some("."),
        Some("HMPREF0629_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. F0108 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575615.HMPREF0670_00001";
/// let this_library_node_name2 = "575615.HMPREF0670_02926";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_f0108_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_f0108_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_f0108_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_f0108_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575615"]),
        None,
        Some("."),
        Some("HMPREF0670_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio tasmaniensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "575788.VS_0001";
/// let this_library_node_name2 = "575788.VS_II1532";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_tasmaniensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_tasmaniensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_tasmaniensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_tasmaniensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["575788"]),
        None,
        Some("."),
        Some("VS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanocaldococcus vulcanius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "579137.Metvu_0001";
/// let this_library_node_name2 = "579137.Metvu_1763";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanocaldococcus_vulcanius_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanocaldococcus_vulcanius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanocaldococcus_vulcanius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanocaldococcus_vulcanius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["579137"]),
        None,
        Some("."),
        Some("Metvu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zymomonas mobilis pomaceae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "579138.Zymop_0001";
/// let this_library_node_name2 = "579138.Zymop_1735";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zymomonas_mobilis_pomaceae_node_name(this_library_node_name1));
/// assert!(is_valid_string_zymomonas_mobilis_pomaceae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zymomonas_mobilis_pomaceae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zymomonas_mobilis_pomaceae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["579138"]),
        None,
        Some("."),
        Some("Zymop_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dickeya dadantii Ech703 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "579405.Dd703_0001";
/// let this_library_node_name2 = "579405.Dd703_4038";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dickeya_dadantii_ech703_node_name(this_library_node_name1));
/// assert!(is_valid_string_dickeya_dadantii_ech703_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dickeya_dadantii_ech703_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dickeya_dadantii_ech703_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["579405"]),
        None,
        Some("."),
        Some("Dd703_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoanaerobacterium thermosaccharolyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "580327.Tthe_0001";
/// let this_library_node_name2 = "580327.Tthe_2757";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoanaerobacterium_thermosaccharolyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoanaerobacterium_thermosaccharolyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoanaerobacterium_thermosaccharolyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoanaerobacterium_thermosaccharolyticum_node_name(
    node_name: &str,
) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["580327"]),
        None,
        Some("."),
        Some("Tthe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoanaerobacter italicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "580331.Thit_0001";
/// let this_library_node_name2 = "580331.Thit_2407";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoanaerobacter_italicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoanaerobacter_italicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoanaerobacter_italicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoanaerobacter_italicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["580331"]),
        None,
        Some("."),
        Some("Thit_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sideroxydans lithotrophicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "580332.Slit_0001";
/// let this_library_node_name2 = "580332.Slit_2997";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sideroxydans_lithotrophicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_sideroxydans_lithotrophicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sideroxydans_lithotrophicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sideroxydans_lithotrophicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["580332"]),
        None,
        Some("."),
        Some("Slit_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermovirga lienii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "580340.Tlie_0001";
/// let this_library_node_name2 = "580340.Tlie_1914";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermovirga_lienii_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermovirga_lienii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermovirga_lienii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermovirga_lienii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["580340"]),
        None,
        Some("."),
        Some("Tlie_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hirschia baltica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "582402.Hbal_0001";
/// let this_library_node_name2 = "582402.Hbal_3222";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hirschia_baltica_node_name(this_library_node_name1));
/// assert!(is_valid_string_hirschia_baltica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hirschia_baltica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hirschia_baltica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["582402"]),
        None,
        Some("."),
        Some("Hbal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rubidibacter lacunae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "582515.KR51_00000010";
/// let this_library_node_name2 = "582515.KR51_00037910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rubidibacter_lacunae_node_name(this_library_node_name1));
/// assert!(is_valid_string_rubidibacter_lacunae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rubidibacter_lacunae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rubidibacter_lacunae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["582515"]),
        None,
        Some("."),
        Some("KR51_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylovorus glucosetrophus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "582744.Msip34_0001";
/// let this_library_node_name2 = "582744.Msip34_2843";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylovorus_glucosetrophus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylovorus_glucosetrophus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylovorus_glucosetrophus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylovorus_glucosetrophus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["582744"]),
        None,
        Some("."),
        Some("Msip34_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomicrobium denitrificans ATCC51888 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "582899.Hden_0001";
/// let this_library_node_name2 = "582899.Hden_3549";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomicrobium_denitrificans_atcc51888_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomicrobium_denitrificans_atcc51888_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomicrobium_denitrificans_atcc51888_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomicrobium_denitrificans_atcc51888_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["582899"]),
        None,
        Some("."),
        Some("Hden_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylotenera mobilis JLW8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "583345.Mmol_0001";
/// let this_library_node_name2 = "583345.Mmol_2349";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylotenera_mobilis_jlw8_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylotenera_mobilis_jlw8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylotenera_mobilis_jlw8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylotenera_mobilis_jlw8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["583345"]),
        None,
        Some("."),
        Some("Mmol_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coraliomargarita akajimensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "583355.Caka_0001";
/// let this_library_node_name2 = "583355.Caka_3136";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coraliomargarita_akajimensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_coraliomargarita_akajimensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coraliomargarita_akajimensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coraliomargarita_akajimensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["583355"]),
        None,
        Some("."),
        Some("Caka_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aminomonas paucivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "584708.Apau_0001";
/// let this_library_node_name2 = "584708.Apau_R0045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aminomonas_paucivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_aminomonas_paucivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aminomonas_paucivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aminomonas_paucivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["584708"]),
        None,
        Some("."),
        Some("Apau_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mobiluncus curtisii ATCC35241 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585198.HMPREF0574_0001";
/// let this_library_node_name2 = "585198.HMPREF0574_1894";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mobiluncus_curtisii_atcc35241_node_name(this_library_node_name1));
/// assert!(is_valid_string_mobiluncus_curtisii_atcc35241_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mobiluncus_curtisii_atcc35241_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mobiluncus_curtisii_atcc35241_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585198"]),
        None,
        Some("."),
        Some("HMPREF0574_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mobiluncus mulieris ATCC35243 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585199.HMPREF0577_0001";
/// let this_library_node_name2 = "585199.HMPREF0577_2300";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mobiluncus_mulieris_atcc35243_node_name(this_library_node_name1));
/// assert!(is_valid_string_mobiluncus_mulieris_atcc35243_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mobiluncus_mulieris_atcc35243_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mobiluncus_mulieris_atcc35243_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585199"]),
        None,
        Some("."),
        Some("HMPREF0577_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis SK321 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585202.SMSK321_0001";
/// let this_library_node_name2 = "585202.SMSK321_1759";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_sk321_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_sk321_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_sk321_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_sk321_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585202"]),
        None,
        Some("."),
        Some("SMSK321_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis SK564 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585203.SMSK564_0001";
/// let this_library_node_name2 = "585203.SMSK564_1897";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_sk564_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_sk564_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_sk564_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_sk564_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585203"]),
        None,
        Some("."),
        Some("SMSK564_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis SK597 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585204.SMSK597_0001";
/// let this_library_node_name2 = "585204.SMSK597_1877";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_sk597_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_sk597_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_sk597_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_sk597_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585204"]),
        None,
        Some("."),
        Some("SMSK597_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseburia hominis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585394.RHOM_00005";
/// let this_library_node_name2 = "585394.RHOM_16935";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseburia_hominis_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseburia_hominis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseburia_hominis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseburia_hominis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585394"]),
        None,
        Some("."),
        Some("RHOM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. KORDI49 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585423.KR49_00010";
/// let this_library_node_name2 = "585423.KR49_14020";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_kordi49_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_kordi49_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_kordi49_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_kordi49_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585423"]),
        None,
        Some("."),
        Some("KR49_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. KORDI52 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585425.KR52_00005";
/// let this_library_node_name2 = "585425.KR52_14475";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_kordi52_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_kordi52_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_kordi52_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_kordi52_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585425"]),
        None,
        Some("."),
        Some("KR52_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oribacterium sinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585501.HMPREF6123_0001";
/// let this_library_node_name2 = "585501.HMPREF6123_2638";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oribacterium_sinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_oribacterium_sinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oribacterium_sinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oribacterium_sinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585501"]),
        None,
        Some("."),
        Some("HMPREF6123_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella bergensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585502.HMPREF0645_0001";
/// let this_library_node_name2 = "585502.HMPREF0645_2825";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_bergensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_bergensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_bergensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_bergensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585502"]),
        None,
        Some("."),
        Some("HMPREF0645_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas noxia ATCC43541 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585503.HMPREF7545_0001";
/// let this_library_node_name2 = "585503.HMPREF7545_2020";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_noxia_atcc43541_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_noxia_atcc43541_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_noxia_atcc43541_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_noxia_atcc43541_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585503"]),
        None,
        Some("."),
        Some("HMPREF7545_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Weissella paramesenteroides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585506.HMPREF0877_0001";
/// let this_library_node_name2 = "585506.HMPREF0877_1953";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_weissella_paramesenteroides_node_name(this_library_node_name1));
/// assert!(is_valid_string_weissella_paramesenteroides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_weissella_paramesenteroides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_weissella_paramesenteroides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585506"]),
        None,
        Some("."),
        Some("HMPREF0877_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus amylolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585524.HMPREF0493_0001";
/// let this_library_node_name2 = "585524.HMPREF0493_1684";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_amylolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_amylolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_amylolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_amylolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585524"]),
        None,
        Some("."),
        Some("HMPREF0493_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium genitalium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585529.HMPREF0291_10001";
/// let this_library_node_name2 = "585529.HMPREF0291_12227";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_genitalium_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_genitalium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_genitalium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_genitalium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585529"]),
        None,
        Some("."),
        Some("HMPREF0291_1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacterium mcbrellneri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585530.HMPREF0183_0001";
/// let this_library_node_name2 = "585530.HMPREF0183_2432";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacterium_mcbrellneri_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacterium_mcbrellneri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacterium_mcbrellneri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacterium_mcbrellneri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585530"]),
        None,
        Some("."),
        Some("HMPREF0183_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aeromicrobium marinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585531.HMPREF0063_10001";
/// let this_library_node_name2 = "585531.HMPREF0063_13083";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aeromicrobium_marinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_aeromicrobium_marinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aeromicrobium_marinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aeromicrobium_marinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585531"]),
        None,
        Some("."),
        Some("HMPREF0063_1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides sp. D20 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "585543.HMPREF0969_00001";
/// let this_library_node_name2 = "585543.HMPREF0969_03652";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_sp_d20_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_sp_d20_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_sp_d20_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_sp_d20_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["585543"]),
        None,
        Some("."),
        Some("HMPREF0969_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanobacillus manasiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "586413.CCDL010000001_gene1";
/// let this_library_node_name2 = "586413.CCDL010000007_gene3757";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanobacillus_manasiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanobacillus_manasiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanobacillus_manasiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanobacillus_manasiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["586413"]),
        None,
        Some("."),
        Some("CCDL01000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Terribacillus aidingensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "586416.GZ22_00040";
/// let this_library_node_name2 = "586416.GZ22_18615";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_terribacillus_aidingensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_terribacillus_aidingensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_terribacillus_aidingensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_terribacillus_aidingensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["586416"]),
        None,
        Some("."),
        Some("GZ22_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas chlororaphis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "587753.EY04_00035";
/// let this_library_node_name2 = "587753.EY04_32520";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_chlororaphis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_chlororaphis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_chlororaphis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_chlororaphis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["587753"]),
        None,
        Some("."),
        Some("EY04_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium papyrosolvens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "588581.Cpap_0001";
/// let this_library_node_name2 = "588581.Cpap_4257";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_papyrosolvens_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_papyrosolvens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_papyrosolvens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_papyrosolvens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["588581"]),
        None,
        Some("."),
        Some("Cpap_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizophagus irregularis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "588596.B7ZFT1";
/// let this_library_node_name2 = "588596.U9V8R2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizophagus_irregularis_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizophagus_irregularis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizophagus_irregularis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizophagus_irregularis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["588596"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kazachstania naganishii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "588726.J7QZB9";
/// let this_library_node_name2 = "588726.J7SBK6";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kazachstania_naganishii_node_name(this_library_node_name1));
/// assert!(is_valid_string_kazachstania_naganishii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kazachstania_naganishii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kazachstania_naganishii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["588726"]),
        None,
        Some("."),
        Some("J7"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevundimonas naejangsanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "588932.JHOF01000001_gene450";
/// let this_library_node_name2 = "588932.JHOF01000028_gene1844";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevundimonas_naejangsanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevundimonas_naejangsanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevundimonas_naejangsanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevundimonas_naejangsanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["588932"]),
        None,
        Some("."),
        Some("JHOF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfurivibrio alkaliphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "589865.DaAHT2_0001";
/// let this_library_node_name2 = "589865.DaAHT2_2678";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfurivibrio_alkaliphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfurivibrio_alkaliphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfurivibrio_alkaliphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfurivibrio_alkaliphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["589865"]),
        None,
        Some("."),
        Some("DaAHT2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alteromonas australica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "589873.EP13_00005";
/// let this_library_node_name2 = "589873.EP13_19230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alteromonas_australica_node_name(this_library_node_name1));
/// assert!(is_valid_string_alteromonas_australica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alteromonas_australica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alteromonas_australica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["589873"]),
        None,
        Some("."),
        Some("EP13_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ferroglobus placidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "589924.Ferp_0001";
/// let this_library_node_name2 = "589924.Ferp_2567";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ferroglobus_placidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ferroglobus_placidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ferroglobus_placidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ferroglobus_placidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["589924"]),
        None,
        Some("."),
        Some("Ferp_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dickeya dadantii Ech586 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "590409.Dd586_0001";
/// let this_library_node_name2 = "590409.Dd586_4216";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dickeya_dadantii_ech586_node_name(this_library_node_name1));
/// assert!(is_valid_string_dickeya_dadantii_ech586_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dickeya_dadantii_ech586_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dickeya_dadantii_ech586_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["590409"]),
        None,
        Some("."),
        Some("Dd586_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellulomonas fimi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "590998.Celf_0001";
/// let this_library_node_name2 = "590998.Celf_3810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellulomonas_fimi_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellulomonas_fimi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellulomonas_fimi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellulomonas_fimi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["590998"]),
        None,
        Some("."),
        Some("Celf_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidaminococcus fermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "591001.Acfer_0001";
/// let this_library_node_name2 = "591001.Acfer_2092";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidaminococcus_fermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidaminococcus_fermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidaminococcus_fermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidaminococcus_fermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["591001"]),
        None,
        Some("."),
        Some("Acfer_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylothermus hellenicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "591019.Shell_0001";
/// let this_library_node_name2 = "591019.Shell_1668";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylothermus_hellenicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylothermus_hellenicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylothermus_hellenicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylothermus_hellenicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["591019"]),
        None,
        Some("."),
        Some("Shell_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobacillus minor 202 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "591023.AM202_00005";
/// let this_library_node_name2 = "591023.AM202_107";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobacillus_minor_202_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobacillus_minor_202_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobacillus_minor_202_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobacillus_minor_202_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["591023"]),
        None,
        Some("."),
        Some("AM202_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. SPB78 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "591157.SSLG_00001";
/// let this_library_node_name2 = "591157.SSLG_06387";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_spb78_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_spb78_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_spb78_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_spb78_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["591157"]),
        None,
        Some("."),
        Some("SSLG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. AA4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "591158.SSMG_00001";
/// let this_library_node_name2 = "591158.SSMG_08419";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_aa4_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_aa4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_aa4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_aa4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["591158"]),
        None,
        Some("."),
        Some("SSMG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces viridochromogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "591159.ACEZ01000001_gene5990";
/// let this_library_node_name2 = "591159.ACEZ01000226_gene1265";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_viridochromogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_viridochromogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_viridochromogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_viridochromogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["591159"]),
        None,
        Some("."),
        Some("ACEZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces pratensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "591167.Sfla_0001";
/// let this_library_node_name2 = "591167.Sfla_6644";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_pratensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_pratensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_pratensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_pratensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["591167"]),
        None,
        Some("."),
        Some("Sfla_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Abiotrophia defectiva nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "592010.GCWU000182_000001";
/// let this_library_node_name2 = "592010.GCWU000182_002011";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_abiotrophia_defectiva_node_name(this_library_node_name1));
/// assert!(is_valid_string_abiotrophia_defectiva_node_name(this_library_node_name2));
/// assert!(!is_valid_string_abiotrophia_defectiva_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_abiotrophia_defectiva_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["592010"]),
        None,
        Some("."),
        Some("GCWU000182_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerobaculum hydrogeniformans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "592015.HMPREF1705_00001";
/// let this_library_node_name2 = "592015.HMPREF1705_02557";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerobaculum_hydrogeniformans_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerobaculum_hydrogeniformans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerobaculum_hydrogeniformans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerobaculum_hydrogeniformans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["592015"]),
        None,
        Some("."),
        Some("HMPREF1705_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Catonella morbi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "592026.GCWU0000282_000006";
/// let this_library_node_name2 = "592026.GCWU0000282_003346";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_catonella_morbi_node_name(this_library_node_name1));
/// assert!(is_valid_string_catonella_morbi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_catonella_morbi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_catonella_morbi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["592026"]),
        None,
        Some("."),
        Some("GCWU0000282_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium botulinum D 1873 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "592027.CLG_A0001";
/// let this_library_node_name2 = "592027.CLG_B2368";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_botulinum_d_1873_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_botulinum_d_1873_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_botulinum_d_1873_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_botulinum_d_1873_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["592027"]),
        None,
        Some("."),
        Some("CLG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dialister invisus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "592028.GCWU000321_00002";
/// let this_library_node_name2 = "592028.GCWU000321_02018";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dialister_invisus_node_name(this_library_node_name1));
/// assert!(is_valid_string_dialister_invisus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dialister_invisus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dialister_invisus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["592028"]),
        None,
        Some("."),
        Some("GCWU000321_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nonlabens dokdonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "592029.DDD_0001";
/// let this_library_node_name2 = "592029.DDD_3618";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nonlabens_dokdonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nonlabens_dokdonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nonlabens_dokdonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nonlabens_dokdonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["592029"]),
        None,
        Some("."),
        Some("DDD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium saphenum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "592031.GCWU000322_00004";
/// let this_library_node_name2 = "592031.GCWU000322_01000";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_saphenum_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_saphenum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_saphenum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_saphenum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["592031"]),
        None,
        Some("."),
        Some("GCWU000322_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea sp. At9b nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "592316.Pat9b_0001";
/// let this_library_node_name2 = "592316.Pat9b_4125";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_sp_at9b_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_sp_at9b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_sp_at9b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_sp_at9b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["592316"]),
        None,
        Some("."),
        Some("Pat9b_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea sp. Sc1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "593105.S7A_00005";
/// let this_library_node_name2 = "593105.S7A_20609";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_sp_sc1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_sp_sc1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_sp_sc1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_sp_sc1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["593105"]),
        None,
        Some("."),
        Some("S7A_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermococcus gammatolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "593117.TGAM_0001";
/// let this_library_node_name2 = "593117.TGAM_2157";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermococcus_gammatolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermococcus_gammatolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermococcus_gammatolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermococcus_gammatolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["593117"]),
        None,
        Some("."),
        Some("TGAM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanoregula formicica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "593750.Metfor_0001";
/// let this_library_node_name2 = "593750.Metfor_2924";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanoregula_formicica_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanoregula_formicica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanoregula_formicica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanoregula_formicica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["593750"]),
        None,
        Some("."),
        Some("Metfor_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellvibrio gilvus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "593907.Celgi_0001";
/// let this_library_node_name2 = "593907.Celgi_3209";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellvibrio_gilvus_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellvibrio_gilvus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellvibrio_gilvus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellvibrio_gilvus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["593907"]),
        None,
        Some("."),
        Some("Celgi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodopirellula sp. SWK7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "595460.RRSWK_00001";
/// let this_library_node_name2 = "595460.RRSWK_07239";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodopirellula_sp_swk7_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodopirellula_sp_swk7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodopirellula_sp_swk7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodopirellula_sp_swk7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["595460"]),
        None,
        Some("."),
        Some("RRSWK_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tolumonas auensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "595494.Tola_0001";
/// let this_library_node_name2 = "595494.Tola_3172";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tolumonas_auensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_tolumonas_auensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tolumonas_auensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tolumonas_auensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["595494"]),
        None,
        Some("."),
        Some("Tola_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylosinus trichosporium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "595536.ADVE02000001_gene1";
/// let this_library_node_name2 = "595536.ADVE02000003_gene4085";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylosinus_trichosporium_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylosinus_trichosporium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylosinus_trichosporium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylosinus_trichosporium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["595536"]),
        None,
        Some("."),
        Some("ADVE0200000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Variovorax paradoxus EPS nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "595537.Varpa_0001";
/// let this_library_node_name2 = "595537.Varpa_6023";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_variovorax_paradoxus_eps_node_name(this_library_node_name1));
/// assert!(is_valid_string_variovorax_paradoxus_eps_node_name(this_library_node_name2));
/// assert!(!is_valid_string_variovorax_paradoxus_eps_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_variovorax_paradoxus_eps_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["595537"]),
        None,
        Some("."),
        Some("Varpa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. A3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "595593.JREV01000001_gene2599";
/// let this_library_node_name2 = "595593.JREV01000069_gene228";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_a3_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_a3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_a3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_a3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["595593"]),
        None,
        Some("."),
        Some("JREV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio fructosivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596151.DesfrDRAFT_0001";
/// let this_library_node_name2 = "596151.DesfrDRAFT_4160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_fructosivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_fructosivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_fructosivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_fructosivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596151"]),
        None,
        Some("."),
        Some("DesfrDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio sp. U5L nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596152.DesU5LDRAFT_0001";
/// let this_library_node_name2 = "596152.DesU5LDRAFT_4133";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_sp_u5l_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_sp_u5l_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_sp_u5l_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_sp_u5l_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596152"]),
        None,
        Some("."),
        Some("DesU5LDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alicycliphilus denitrificans BC nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596153.Alide_0001";
/// let this_library_node_name2 = "596153.Alide_4645";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alicycliphilus_denitrificans_bc_node_name(this_library_node_name1));
/// assert!(is_valid_string_alicycliphilus_denitrificans_bc_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alicycliphilus_denitrificans_bc_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alicycliphilus_denitrificans_bc_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596153"]),
        None,
        Some("."),
        Some("Alide_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alicycliphilus denitrificans K601 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596154.Alide2_0001";
/// let this_library_node_name2 = "596154.Alide2_4838";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alicycliphilus_denitrificans_k601_node_name(this_library_node_name1));
/// assert!(is_valid_string_alicycliphilus_denitrificans_k601_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alicycliphilus_denitrificans_k601_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alicycliphilus_denitrificans_k601_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596154"]),
        None,
        Some("."),
        Some("Alide2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptostreptococcus stomatis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596315.HMPREF0634_0001";
/// let this_library_node_name2 = "596315.HMPREF0634_1603";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptostreptococcus_stomatis_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptostreptococcus_stomatis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptostreptococcus_stomatis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptostreptococcus_stomatis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596315"]),
        None,
        Some("."),
        Some("HMPREF0634_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus warneri L37603 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596319.STAWA0001_0003";
/// let this_library_node_name2 = "596319.STAWA0001_2471";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_warneri_l37603_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_warneri_l37603_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_warneri_l37603_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_warneri_l37603_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596319"]),
        None,
        Some("."),
        Some("STAWA0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria flavescens SK114 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596320.NEIFL0001_0001";
/// let this_library_node_name2 = "596320.NEIFL0001_2423";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_flavescens_sk114_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_flavescens_sk114_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_flavescens_sk114_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_flavescens_sk114_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596320"]),
        None,
        Some("."),
        Some("NEIFL0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptotrichia goodfellowii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596323.HMPREF0554_0001";
/// let this_library_node_name2 = "596323.HMPREF0554_2486";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptotrichia_goodfellowii_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptotrichia_goodfellowii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptotrichia_goodfellowii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptotrichia_goodfellowii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596323"]),
        None,
        Some("."),
        Some("HMPREF0554_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema vincentii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596324.TREVI0001_0001";
/// let this_library_node_name2 = "596324.TREVI0001_2620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_vincentii_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_vincentii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_vincentii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_vincentii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596324"]),
        None,
        Some("."),
        Some("TREVI0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas uenonis 603 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596327.PORUE0001_0001";
/// let this_library_node_name2 = "596327.PORUE0001_2044";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_uenonis_603_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_uenonis_603_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_uenonis_603_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_uenonis_603_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596327"]),
        None,
        Some("."),
        Some("PORUE0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mobiluncus mulieris 281 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596328.HMPREF0578_0001";
/// let this_library_node_name2 = "596328.HMPREF0578_2398";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mobiluncus_mulieris_281_node_name(this_library_node_name1));
/// assert!(is_valid_string_mobiluncus_mulieris_281_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mobiluncus_mulieris_281_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mobiluncus_mulieris_281_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596328"]),
        None,
        Some("."),
        Some("HMPREF0578_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptostreptococcus anaerobius 653L nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596329.HMPREF0631_0001";
/// let this_library_node_name2 = "596329.HMPREF0631_1937";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptostreptococcus_anaerobius_653l_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptostreptococcus_anaerobius_653l_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptostreptococcus_anaerobius_653l_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptostreptococcus_anaerobius_653l_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596329"]),
        None,
        Some("."),
        Some("HMPREF0631_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus lacrimalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "596330.HMPREF0628_0001";
/// let this_library_node_name2 = "596330.HMPREF0628_1656";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_lacrimalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_lacrimalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_lacrimalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_lacrimalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["596330"]),
        None,
        Some("."),
        Some("HMPREF0628_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brenneria sp. EniD312 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "598467.BrE312_0001";
/// let this_library_node_name2 = "598467.BrE312_4540";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brenneria_sp_enid312_node_name(this_library_node_name1));
/// assert!(is_valid_string_brenneria_sp_enid312_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brenneria_sp_enid312_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brenneria_sp_enid312_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["598467"]),
        None,
        Some("."),
        Some("BrE312_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nautilia profundicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "598659.NAMH_0001";
/// let this_library_node_name2 = "598659.NAMH_1806";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nautilia_profundicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_nautilia_profundicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nautilia_profundicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nautilia_profundicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["598659"]),
        None,
        Some("."),
        Some("NAMH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blattabacterium sp. BPLAN nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "600809.BPLAN_001";
/// let this_library_node_name2 = "600809.BPLAN_p004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blattabacterium_sp_bplan_node_name(this_library_node_name1));
/// assert!(is_valid_string_blattabacterium_sp_bplan_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blattabacterium_sp_bplan_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blattabacterium_sp_bplan_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["600809"]),
        None,
        Some("."),
        Some("BPLAN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Meiothermus rufus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "604331.AUHY01000001_gene1222";
/// let this_library_node_name2 = "604331.AUHY01000123_gene536";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_meiothermus_rufus_node_name(this_library_node_name1));
/// assert!(is_valid_string_meiothermus_rufus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_meiothermus_rufus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_meiothermus_rufus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["604331"]),
        None,
        Some("."),
        Some("AUHY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermococcus sibiricus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "604354.TSIB_0001";
/// let this_library_node_name2 = "604354.TSIB_2061";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermococcus_sibiricus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermococcus_sibiricus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermococcus_sibiricus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermococcus_sibiricus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["604354"]),
        None,
        Some("."),
        Some("TSIB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldicellulosiruptor obsidiansis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "608506.COB47_0001";
/// let this_library_node_name2 = "608506.COB47_2333";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldicellulosiruptor_obsidiansis_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldicellulosiruptor_obsidiansis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldicellulosiruptor_obsidiansis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldicellulosiruptor_obsidiansis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["608506"]),
        None,
        Some("."),
        Some("COB47_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oribacterium sp. F0262 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "608534.GCWU000341_00001";
/// let this_library_node_name2 = "608534.GCWU000341_03005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oribacterium_sp_f0262_node_name(this_library_node_name1));
/// assert!(is_valid_string_oribacterium_sp_f0262_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oribacterium_sp_f0262_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oribacterium_sp_f0262_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["608534"]),
        None,
        Some("."),
        Some("GCWU000341_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hydrogenobacter thermophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "608538.HTH_0001";
/// let this_library_node_name2 = "608538.HTH_1917";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hydrogenobacter_thermophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_hydrogenobacter_thermophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hydrogenobacter_thermophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hydrogenobacter_thermophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["608538"]),
        None,
        Some("."),
        Some("HTH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium saccharolyticum WM1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "610130.Closa_0001";
/// let this_library_node_name2 = "610130.Closa_4302";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_saccharolyticum_wm1_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_saccharolyticum_wm1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_saccharolyticum_wm1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_saccharolyticum_wm1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["610130"]),
        None,
        Some("."),
        Some("Closa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter bilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "613026.HRAG_00001";
/// let this_library_node_name2 = "613026.HRAG_02521";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_bilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_bilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_bilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_bilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["613026"]),
        None,
        Some("."),
        Some("HRAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodoferax saidenbachensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "614083.AWQR01000001_gene3028";
/// let this_library_node_name2 = "614083.AWQR01000070_gene3488";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodoferax_saidenbachensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodoferax_saidenbachensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodoferax_saidenbachensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodoferax_saidenbachensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["614083"]),
        None,
        Some("."),
        Some("AWQR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arenibacter algicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "616991.JPOO01000001_gene2717";
/// let this_library_node_name2 = "616991.JPOO01000003_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arenibacter_algicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_arenibacter_algicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arenibacter_algicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arenibacter_algicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["616991"]),
        None,
        Some("."),
        Some("JPOO0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio splendidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "617140.AJZE01000001_gene2302";
/// let this_library_node_name2 = "617140.AJZE01000142_gene1203";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_splendidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_splendidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_splendidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_splendidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["617140"]),
        None,
        Some("."),
        Some("AJZE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. F0295 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "619693.HMPREF6745_0001";
/// let this_library_node_name2 = "619693.HMPREF6745_3094";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_f0295_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_f0295_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_f0295_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_f0295_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["619693"]),
        None,
        Some("."),
        Some("HMPREF6745_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquimarina agarilytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "620914.JH621246_gene2681";
/// let this_library_node_name2 = "620914.JH621334_gene2102";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquimarina_agarilytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquimarina_agarilytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquimarina_agarilytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquimarina_agarilytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["620914"]),
        None,
        Some("."),
        Some("JH621"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. D14 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "621372.ACIH01000001_gene457";
/// let this_library_node_name2 = "621372.ACIH01000299_gene3029";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_d14_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_d14_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_d14_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_d14_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["621372"]),
        None,
        Some("."),
        Some("ACIH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseburia inulinivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "622312.ROSEINA2194_00001";
/// let this_library_node_name2 = "622312.ROSEINA2194_04472";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseburia_inulinivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseburia_inulinivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseburia_inulinivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseburia_inulinivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["622312"]),
        None,
        Some("."),
        Some("ROSEINA2194_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylocystis sp. ATCC49242 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "622637.KE124769_gene189";
/// let this_library_node_name2 = "622637.KE124774_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylocystis_sp_atcc49242_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylocystis_sp_atcc49242_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylocystis_sp_atcc49242_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylocystis_sp_atcc49242_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["622637"]),
        None,
        Some("."),
        Some("KE1247"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Granulicatella elegans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "626369.HMPREF0446_00001";
/// let this_library_node_name2 = "626369.HMPREF0446_01733";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_granulicatella_elegans_node_name(this_library_node_name1));
/// assert!(is_valid_string_granulicatella_elegans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_granulicatella_elegans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_granulicatella_elegans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["626369"]),
        None,
        Some("."),
        Some("HMPREF0446_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia glumae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "626418.339305139";
/// let this_library_node_name2 = "626418.bglu_2p1170";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_glumae_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_glumae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_glumae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_glumae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["626418"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella tannerae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "626522.GCWU000325_00001";
/// let this_library_node_name2 = "626522.GCWU000325_02865";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_tannerae_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_tannerae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_tannerae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_tannerae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["626522"]),
        None,
        Some("."),
        Some("GCWU000325_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shuttleworthia satelles nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "626523.GCWU000342_00001";
/// let this_library_node_name2 = "626523.GCWU000342_02324";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shuttleworthia_satelles_node_name(this_library_node_name1));
/// assert!(is_valid_string_shuttleworthia_satelles_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shuttleworthia_satelles_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shuttleworthia_satelles_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["626523"]),
        None,
        Some("."),
        Some("GCWU000342_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter nanhaiticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "626887.J057_00005";
/// let this_library_node_name2 = "626887.J057_23990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_nanhaiticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_nanhaiticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_nanhaiticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_nanhaiticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["626887"]),
        None,
        Some("."),
        Some("J057_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phascolarctobacterium succinatutens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "626939.HMPREF9443_00001";
/// let this_library_node_name2 = "626939.HMPREF9443_02203";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phascolarctobacterium_succinatutens_node_name(this_library_node_name1));
/// assert!(is_valid_string_phascolarctobacterium_succinatutens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phascolarctobacterium_succinatutens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phascolarctobacterium_succinatutens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["626939"]),
        None,
        Some("."),
        Some("HMPREF9443_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium sp. SYK6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "627192.SLG_00010";
/// let this_library_node_name2 = "627192.SLG_p_01500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_sp_syk6_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_sp_syk6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_sp_syk6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_sp_syk6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["627192"]),
        None,
        Some("."),
        Some("SLG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas syringae maculicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "629265.PMA4326_00005";
/// let this_library_node_name2 = "629265.PMA4326_29977";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_syringae_maculicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_syringae_maculicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_syringae_maculicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_syringae_maculicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["629265"]),
        None,
        Some("."),
        Some("PMA4326_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus hominis SK119 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "629742.STAHO0001_0001";
/// let this_library_node_name2 = "629742.STAHO0001_2269";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_hominis_sk119_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_hominis_sk119_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_hominis_sk119_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_hominis_sk119_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["629742"]),
        None,
        Some("."),
        Some("STAHO0001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. Mn802worker nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "629773.AORY01000001_gene1986";
/// let this_library_node_name2 = "629773.AORY01000021_gene2410";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_mn802worker_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_mn802worker_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_mn802worker_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_mn802worker_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["629773"]),
        None,
        Some("."),
        Some("AORY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shimwellia blattae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "630626.EBL_c00010";
/// let this_library_node_name2 = "630626.EBL_c40170";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shimwellia_blattae_node_name(this_library_node_name1));
/// assert!(is_valid_string_shimwellia_blattae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shimwellia_blattae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shimwellia_blattae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["630626"]),
        None,
        Some("."),
        Some("EBL_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiorhodovibrio sp. 970 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "631362.Thi970DRAFT_00001";
/// let this_library_node_name2 = "631362.Thi970DRAFT_05011";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiorhodovibrio_sp_970_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiorhodovibrio_sp_970_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiorhodovibrio_sp_970_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiorhodovibrio_sp_970_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["631362"]),
        None,
        Some("."),
        Some("Thi970DRAFT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lutibaculum baratangense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "631454.N177_0001";
/// let this_library_node_name2 = "631454.N177_4221";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lutibaculum_baratangense_node_name(this_library_node_name1));
/// assert!(is_valid_string_lutibaculum_baratangense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lutibaculum_baratangense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lutibaculum_baratangense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["631454"]),
        None,
        Some("."),
        Some("N177_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium butyricum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "632245.CLP_0001";
/// let this_library_node_name2 = "632245.CLP_4461";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_butyricum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_butyricum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_butyricum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_butyricum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["632245"]),
        None,
        Some("."),
        Some("CLP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldicellulosiruptor hydrothermalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "632292.Calhy_0001";
/// let this_library_node_name2 = "632292.Calhy_2625";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldicellulosiruptor_hydrothermalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldicellulosiruptor_hydrothermalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldicellulosiruptor_hydrothermalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldicellulosiruptor_hydrothermalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["632292"]),
        None,
        Some("."),
        Some("Calhy_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldicellulosiruptor kristjanssonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "632335.Calkr_0001";
/// let this_library_node_name2 = "632335.Calkr_2652";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldicellulosiruptor_kristjanssonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldicellulosiruptor_kristjanssonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldicellulosiruptor_kristjanssonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldicellulosiruptor_kristjanssonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["632335"]),
        None,
        Some("."),
        Some("Calkr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldicellulosiruptor owensensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "632518.Calow_0001";
/// let this_library_node_name2 = "632518.Calow_2268";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldicellulosiruptor_owensensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldicellulosiruptor_owensensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldicellulosiruptor_owensensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldicellulosiruptor_owensensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["632518"]),
        None,
        Some("."),
        Some("Calow_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thalassobium sp. R2A62 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "633131.TR2A62_0001";
/// let this_library_node_name2 = "633131.TR2A62_3710";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thalassobium_sp_r2a62_node_name(this_library_node_name1));
/// assert!(is_valid_string_thalassobium_sp_r2a62_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thalassobium_sp_r2a62_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thalassobium_sp_r2a62_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["633131"]),
        None,
        Some("."),
        Some("TR2A62_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Olsenella uli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "633147.Olsu_0001";
/// let this_library_node_name2 = "633147.Olsu_1786";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_olsenella_uli_node_name(this_library_node_name1));
/// assert!(is_valid_string_olsenella_uli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_olsenella_uli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_olsenella_uli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["633147"]),
        None,
        Some("."),
        Some("Olsu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermosphaera aggregans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "633148.Tagg_0001";
/// let this_library_node_name2 = "633148.Tagg_1410";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermosphaera_aggregans_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermosphaera_aggregans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermosphaera_aggregans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermosphaera_aggregans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["633148"]),
        None,
        Some("."),
        Some("Tagg_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevundimonas subvibrioides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "633149.Bresu_0001";
/// let this_library_node_name2 = "633149.Bresu_3337";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevundimonas_subvibrioides_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevundimonas_subvibrioides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevundimonas_subvibrioides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevundimonas_subvibrioides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["633149"]),
        None,
        Some("."),
        Some("Bresu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium cellulosolvens 6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "633697.EubceDRAFT1_0001";
/// let this_library_node_name2 = "633697.EubceDRAFT1_2948";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_cellulosolvens_6_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_cellulosolvens_6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_cellulosolvens_6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_cellulosolvens_6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["633697"]),
        None,
        Some("."),
        Some("EubceDRAFT1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aggregatibacter aphrophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "634176.NT05HA_0001";
/// let this_library_node_name2 = "634176.NT05HA_2377";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aggregatibacter_aphrophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_aggregatibacter_aphrophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aggregatibacter_aphrophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aggregatibacter_aphrophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["634176"]),
        None,
        Some("."),
        Some("NT05HA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Komagataeibacter medellinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "634177.GLX_00010";
/// let this_library_node_name2 = "634177.GLX_31950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_komagataeibacter_medellinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_komagataeibacter_medellinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_komagataeibacter_medellinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_komagataeibacter_medellinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["634177"]),
        None,
        Some("."),
        Some("GLX_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetobacter pasteurianus IFO328301 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "634452.APA01_00010";
/// let this_library_node_name2 = "634452.APA01_44200";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetobacter_pasteurianus_ifo328301_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetobacter_pasteurianus_ifo328301_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetobacter_pasteurianus_ifo328301_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetobacter_pasteurianus_ifo328301_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["634452"]),
        None,
        Some("."),
        Some("APA01_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloarcula hispanica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "634497.HAH_0001";
/// let this_library_node_name2 = "634497.HAH_5363";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloarcula_hispanica_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloarcula_hispanica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloarcula_hispanica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloarcula_hispanica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["634497"]),
        None,
        Some("."),
        Some("HAH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanobrevibacter ruminantium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "634498.mru_0001";
/// let this_library_node_name2 = "634498.mru_2219";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanobrevibacter_ruminantium_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanobrevibacter_ruminantium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanobrevibacter_ruminantium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanobrevibacter_ruminantium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["634498"]),
        None,
        Some("."),
        Some("mru_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erwinia pyrifoliae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "634499.EpC_00010";
/// let this_library_node_name2 = "634499.EpC_pEp360380";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erwinia_pyrifoliae_node_name(this_library_node_name1));
/// assert!(is_valid_string_erwinia_pyrifoliae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erwinia_pyrifoliae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erwinia_pyrifoliae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["634499"]),
        None,
        Some("."),
        Some("EpC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erwinia billingiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "634500.EbC_00010";
/// let this_library_node_name2 = "634500.EbC_pEb10201150";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erwinia_billingiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_erwinia_billingiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erwinia_billingiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erwinia_billingiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["634500"]),
        None,
        Some("."),
        Some("EbC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella grahamii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "634504.Bgr_00010";
/// let this_library_node_name2 = "634504.Bgr_p00310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_grahamii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_grahamii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_grahamii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_grahamii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["634504"]),
        None,
        Some("."),
        Some("Bgr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacillus thermoglucosidasius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "634956.Geoth_0001";
/// let this_library_node_name2 = "634956.Geoth_3949";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacillus_thermoglucosidasius_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacillus_thermoglucosidasius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacillus_thermoglucosidasius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacillus_thermoglucosidasius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["634956"]),
        None,
        Some("."),
        Some("Geoth_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptotrichia hofstadii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "634994.GCWU000323_00001";
/// let this_library_node_name2 = "634994.GCWU000323_02905";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptotrichia_hofstadii_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptotrichia_hofstadii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptotrichia_hofstadii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptotrichia_hofstadii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["634994"]),
        None,
        Some("."),
        Some("GCWU000323_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermincola potens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "635013.TherJR_0001";
/// let this_library_node_name2 = "635013.TherJR_3017";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermincola_potens_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermincola_potens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermincola_potens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermincola_potens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["635013"]),
        None,
        Some("."),
        Some("TherJR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidithiobacillus caldus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "637389.Acaty_c0001";
/// let this_library_node_name2 = "637389.Acaty_m0208";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidithiobacillus_caldus_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidithiobacillus_caldus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidithiobacillus_caldus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidithiobacillus_caldus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["637389"]),
        None,
        Some("."),
        Some("Acaty_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidithiobacillus thiooxidans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "637390.AFOH01000001_gene905";
/// let this_library_node_name2 = "637390.AFOH01000164_gene324";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidithiobacillus_thiooxidans_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidithiobacillus_thiooxidans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidithiobacillus_thiooxidans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidithiobacillus_thiooxidans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["637390"]),
        None,
        Some("."),
        Some("AFOH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella violacea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "637905.SVI_0001";
/// let this_library_node_name2 = "637905.SVI_4346";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_violacea_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_violacea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_violacea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_violacea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["637905"]),
        None,
        Some("."),
        Some("SVI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citrobacter rodentium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "637910.ROD_00011";
/// let this_library_node_name2 = "637910.ROD_p2551";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citrobacter_rodentium_node_name(this_library_node_name1));
/// assert!(is_valid_string_citrobacter_rodentium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citrobacter_rodentium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citrobacter_rodentium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["637910"]),
        None,
        Some("."),
        Some("ROD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobacillus minor NM305 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "637911.AM305_00005";
/// let this_library_node_name2 = "637911.AM305_12240";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobacillus_minor_nm305_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobacillus_minor_nm305_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobacillus_minor_nm305_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobacillus_minor_nm305_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["637911"]),
        None,
        Some("."),
        Some("AM305_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Granulicatella adiacens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "638301.HMPREF0444_0001";
/// let this_library_node_name2 = "638301.HMPREF0444_1920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_granulicatella_adiacens_node_name(this_library_node_name1));
/// assert!(is_valid_string_granulicatella_adiacens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_granulicatella_adiacens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_granulicatella_adiacens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["638301"]),
        None,
        Some("."),
        Some("HMPREF0444_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas flueggei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "638302.HMPREF0908_0001";
/// let this_library_node_name2 = "638302.HMPREF0908_2117";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_flueggei_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_flueggei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_flueggei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_flueggei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["638302"]),
        None,
        Some("."),
        Some("HMPREF0908_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermocrinis albus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "638303.Thal_0001";
/// let this_library_node_name2 = "638303.Thal_1603";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermocrinis_albus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermocrinis_albus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermocrinis_albus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermocrinis_albus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["638303"]),
        None,
        Some("."),
        Some("Thal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidobacteria bacterium KBS146 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "639030.JHVA01000001_gene1";
/// let this_library_node_name2 = "639030.JHVA01000002_gene4001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidobacteria_bacterium_kbs146_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidobacteria_bacterium_kbs146_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidobacteria_bacterium_kbs146_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidobacteria_bacterium_kbs146_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["639030"]),
        None,
        Some("."),
        Some("JHVA0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deferribacter desulfuricans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "639282.DEFDS_0001";
/// let this_library_node_name2 = "639282.DEFDS_P266";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deferribacter_desulfuricans_node_name(this_library_node_name1));
/// assert!(is_valid_string_deferribacter_desulfuricans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deferribacter_desulfuricans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deferribacter_desulfuricans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["639282"]),
        None,
        Some("."),
        Some("DEFDS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Starkeya novella nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "639283.Snov_0001";
/// let this_library_node_name2 = "639283.Snov_4512";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_starkeya_novella_node_name(this_library_node_name1));
/// assert!(is_valid_string_starkeya_novella_node_name(this_library_node_name2));
/// assert!(!is_valid_string_starkeya_novella_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_starkeya_novella_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["639283"]),
        None,
        Some("."),
        Some("Snov_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dechlorosoma suillum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "640081.Dsui_0001";
/// let this_library_node_name2 = "640081.Dsui_3539";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dechlorosoma_suillum_node_name(this_library_node_name1));
/// assert!(is_valid_string_dechlorosoma_suillum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dechlorosoma_suillum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dechlorosoma_suillum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["640081"]),
        None,
        Some("."),
        Some("Dsui_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Segniliparus rotundus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "640132.Srot_0001";
/// let this_library_node_name2 = "640132.Srot_3075";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_segniliparus_rotundus_node_name(this_library_node_name1));
/// assert!(is_valid_string_segniliparus_rotundus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_segniliparus_rotundus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_segniliparus_rotundus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["640132"]),
        None,
        Some("."),
        Some("Srot_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sp. CCGE1001 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "640510.BC1001_0001";
/// let this_library_node_name2 = "640510.BC1001_6074";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sp_ccge1001_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sp_ccge1001_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sp_ccge1001_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sp_ccge1001_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["640510"]),
        None,
        Some("."),
        Some("BC1001_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sp. CCGE1002 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "640511.BC1002_0001";
/// let this_library_node_name2 = "640511.BC1002_7263";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sp_ccge1002_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sp_ccge1002_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sp_ccge1002_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sp_ccge1002_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["640511"]),
        None,
        Some("."),
        Some("BC1002_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sp. CCGE1003 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "640512.BC1003_0001";
/// let this_library_node_name2 = "640512.BC1003_6105";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sp_ccge1003_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sp_ccge1003_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sp_ccge1003_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sp_ccge1003_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["640512"]),
        None,
        Some("."),
        Some("BC1003_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacter asburiae LF7a nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "640513.Entas_0001";
/// let this_library_node_name2 = "640513.Entas_4696";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacter_asburiae_lf7a_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacter_asburiae_lf7a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacter_asburiae_lf7a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacter_asburiae_lf7a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["640513"]),
        None,
        Some("."),
        Some("Entas_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. DLVIII nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "641107.CDLVIII_0001";
/// let this_library_node_name2 = "641107.CDLVIII_5966";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_dlviii_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_dlviii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_dlviii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_dlviii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["641107"]),
        None,
        Some("."),
        Some("CDLVIII_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus flavefaciens FD1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "641112.ACOK01000001_gene3465";
/// let this_library_node_name2 = "641112.ACOK01000119_gene1586";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_flavefaciens_fd1_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_flavefaciens_fd1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_flavefaciens_fd1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_flavefaciens_fd1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["641112"]),
        None,
        Some("."),
        Some("ACOK01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga granulosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "641143.HMPREF9331_00001";
/// let this_library_node_name2 = "641143.HMPREF9331_02560";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_granulosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_granulosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_granulosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_granulosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["641143"]),
        None,
        Some("."),
        Some("HMPREF9331_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Scardovia inopinata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "641146.HMPREF9020_00002";
/// let this_library_node_name2 = "641146.HMPREF9020_01574";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_scardovia_inopinata_node_name(this_library_node_name1));
/// assert!(is_valid_string_scardovia_inopinata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_scardovia_inopinata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_scardovia_inopinata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["641146"]),
        None,
        Some("."),
        Some("HMPREF9020_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Simonsiella muelleri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "641147.HMPREF9021_00001";
/// let this_library_node_name2 = "641147.HMPREF9021_02720";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_simonsiella_muelleri_node_name(this_library_node_name1));
/// assert!(is_valid_string_simonsiella_muelleri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_simonsiella_muelleri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_simonsiella_muelleri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["641147"]),
        None,
        Some("."),
        Some("HMPREF9021_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria sp. F0314 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "641149.HMPREF9016_00001";
/// let this_library_node_name2 = "641149.HMPREF9016_02319";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_sp_f0314_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_sp_f0314_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_sp_f0314_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_sp_f0314_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["641149"]),
        None,
        Some("."),
        Some("HMPREF9016_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio desulfuricans ND132 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "641491.DND132_0001";
/// let this_library_node_name2 = "641491.DND132_3470";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_desulfuricans_nd132_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_desulfuricans_nd132_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_desulfuricans_nd132_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_desulfuricans_nd132_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["641491"]),
        None,
        Some("."),
        Some("DND132_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyclobacterium qasimii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "641524.ADICYQ_0001";
/// let this_library_node_name2 = "641524.ADICYQ_5999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyclobacterium_qasimii_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyclobacterium_qasimii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyclobacterium_qasimii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyclobacterium_qasimii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["641524"]),
        None,
        Some("."),
        Some("ADICYQ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Winogradskyella psychrotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "641526.ADIWIN_0001";
/// let this_library_node_name2 = "641526.ADIWIN_4068";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_winogradskyella_psychrotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_winogradskyella_psychrotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_winogradskyella_psychrotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_winogradskyella_psychrotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["641526"]),
        None,
        Some("."),
        Some("ADIWIN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tatumella morbirosei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "642227.HA49_00005";
/// let this_library_node_name2 = "642227.HA49_21380";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tatumella_morbirosei_node_name(this_library_node_name1));
/// assert!(is_valid_string_tatumella_morbirosei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tatumella_morbirosei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tatumella_morbirosei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["642227"]),
        None,
        Some("."),
        Some("HA49_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium lentocellum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "642492.Clole_0001";
/// let this_library_node_name2 = "642492.Clole_4273";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_lentocellum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_lentocellum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_lentocellum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_lentocellum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["642492"]),
        None,
        Some("."),
        Some("Clole_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microchaete sp. PCC7126 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "643473.KB235930_gene1";
/// let this_library_node_name2 = "643473.KB235932_gene5059";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microchaete_sp_pcc7126_node_name(this_library_node_name1));
/// assert!(is_valid_string_microchaete_sp_pcc7126_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microchaete_sp_pcc7126_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microchaete_sp_pcc7126_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["643473"]),
        None,
        Some("."),
        Some("KB23593"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio aespoeensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "643562.Daes_0001";
/// let this_library_node_name2 = "643562.Daes_3345";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_aespoeensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_aespoeensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_aespoeensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_aespoeensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["643562"]),
        None,
        Some("."),
        Some("Daes_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Syntrophothermus lipocalidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "643648.Slip_0001";
/// let this_library_node_name2 = "643648.Slip_R0041";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_syntrophothermus_lipocalidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_syntrophothermus_lipocalidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_syntrophothermus_lipocalidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_syntrophothermus_lipocalidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["643648"]),
        None,
        Some("."),
        Some("Slip_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marivirga tractuosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "643867.Ftrac_0001";
/// let this_library_node_name2 = "643867.Ftrac_R0020";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marivirga_tractuosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_marivirga_tractuosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marivirga_tractuosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marivirga_tractuosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["643867"]),
        None,
        Some("."),
        Some("Ftrac_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Silicibacter sp. TrichCH4B nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "644076.SCH4B_0001";
/// let this_library_node_name2 = "644076.SCH4B_4842";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_silicibacter_sp_trichch4b_node_name(this_library_node_name1));
/// assert!(is_valid_string_silicibacter_sp_trichch4b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_silicibacter_sp_trichch4b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_silicibacter_sp_trichch4b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["644076"]),
        None,
        Some("."),
        Some("SCH4B_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Silicibacter lacuscaerulensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "644107.SL1157_0001";
/// let this_library_node_name2 = "644107.SL1157_A0274";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_silicibacter_lacuscaerulensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_silicibacter_lacuscaerulensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_silicibacter_lacuscaerulensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_silicibacter_lacuscaerulensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["644107"]),
        None,
        Some("."),
        Some("SL1157_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanocaldococcus sp. FS40622 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "644281.MFS40622_0001";
/// let this_library_node_name2 = "644281.MFS40622_1848";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanocaldococcus_sp_fs40622_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanocaldococcus_sp_fs40622_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanocaldococcus_sp_fs40622_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanocaldococcus_sp_fs40622_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["644281"]),
        None,
        Some("."),
        Some("MFS40622_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfarculus baarsii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "644282.Deba_0001";
/// let this_library_node_name2 = "644282.Deba_R0033";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfarculus_baarsii_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfarculus_baarsii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfarculus_baarsii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfarculus_baarsii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["644282"]),
        None,
        Some("."),
        Some("Deba_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Micromonospora aurantiaca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "644283.Micau_0001";
/// let this_library_node_name2 = "644283.Micau_6298";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_micromonospora_aurantiaca_node_name(this_library_node_name1));
/// assert!(is_valid_string_micromonospora_aurantiaca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_micromonospora_aurantiaca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_micromonospora_aurantiaca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["644283"]),
        None,
        Some("."),
        Some("Micau_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arcanobacterium haemolyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "644284.Arch_0001";
/// let this_library_node_name2 = "644284.Arch_R0043";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arcanobacterium_haemolyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_arcanobacterium_haemolyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arcanobacterium_haemolyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arcanobacterium_haemolyticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["644284"]),
        None,
        Some("."),
        Some("Arch_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia neofelifaecis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "644548.SCNU_00005";
/// let this_library_node_name2 = "644548.SCNU_20261";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_neofelifaecis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_neofelifaecis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_neofelifaecis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_neofelifaecis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["644548"]),
        None,
        Some("."),
        Some("SCNU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas stutzeri RCH2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "644801.Psest_0001";
/// let this_library_node_name2 = "644801.Psest_4376";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_stutzeri_rch2_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_stutzeri_rch2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_stutzeri_rch2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_stutzeri_rch2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["644801"]),
        None,
        Some("."),
        Some("Psest_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermaerobacter marianensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "644966.Tmar_0001";
/// let this_library_node_name2 = "644966.Tmar_R0053";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermaerobacter_marianensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermaerobacter_marianensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermaerobacter_marianensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermaerobacter_marianensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["644966"]),
        None,
        Some("."),
        Some("Tmar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio sp. FW1012B nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "644968.DFW101_0001";
/// let this_library_node_name2 = "644968.DFW101_3733";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_sp_fw1012b_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_sp_fw1012b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_sp_fw1012b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_sp_fw1012b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["644968"]),
        None,
        Some("."),
        Some("DFW101_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium kroppenstedtii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "645127.ckrop_0000";
/// let this_library_node_name2 = "645127.ckrop_3008";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_kroppenstedtii_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_kroppenstedtii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_kroppenstedtii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_kroppenstedtii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["645127"]),
        None,
        Some("."),
        Some("ckrop_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. e14 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "645465.ACUR01000001_gene2159";
/// let this_library_node_name2 = "645465.ACUR01000716_gene3871";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_e14_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_e14_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_e14_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_e14_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["645465"]),
        None,
        Some("."),
        Some("ACUR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Jonquetella anthropi E333E1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "645512.GCWU000246_00001";
/// let this_library_node_name2 = "645512.GCWU000246_01894";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_jonquetella_anthropi_e333e1_node_name(this_library_node_name1));
/// assert!(is_valid_string_jonquetella_anthropi_e333e1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_jonquetella_anthropi_e333e1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_jonquetella_anthropi_e333e1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["645512"]),
        None,
        Some("."),
        Some("GCWU000246_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Syntrophobotulus glycolicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "645991.Sgly_0001";
/// let this_library_node_name2 = "645991.Sgly_R0066";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_syntrophobotulus_glycolicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_syntrophobotulus_glycolicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_syntrophobotulus_glycolicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_syntrophobotulus_glycolicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["645991"]),
        None,
        Some("."),
        Some("Sgly_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfosporosinus acidiphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "646529.Desaci_0001";
/// let this_library_node_name2 = "646529.Desaci_4724";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfosporosinus_acidiphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfosporosinus_acidiphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfosporosinus_acidiphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfosporosinus_acidiphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["646529"]),
        None,
        Some("."),
        Some("Desaci_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanothermococcus okinawensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "647113.Metok_0001";
/// let this_library_node_name2 = "647113.Metok_1631";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanothermococcus_okinawensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanothermococcus_okinawensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanothermococcus_okinawensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanothermococcus_okinawensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["647113"]),
        None,
        Some("."),
        Some("Metok_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodomicrobium vannielii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "648757.Rvan_0001";
/// let this_library_node_name2 = "648757.Rvan_3691";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodomicrobium_vannielii_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodomicrobium_vannielii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodomicrobium_vannielii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodomicrobium_vannielii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["648757"]),
        None,
        Some("."),
        Some("Rvan_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium sp. MB200 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "648885.KB316282_gene1";
/// let this_library_node_name2 = "648885.KB316287_gene5036";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_sp_mb200_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_sp_mb200_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_sp_mb200_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_sp_mb200_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["648885"]),
        None,
        Some("."),
        Some("KB31628"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermovibrio ammonificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "648996.Theam_0001";
/// let this_library_node_name2 = "648996.Theam_1831";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermovibrio_ammonificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermovibrio_ammonificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermovibrio_ammonificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermovibrio_ammonificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["648996"]),
        None,
        Some("."),
        Some("Theam_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leadbetterella byssophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "649349.Lbys_0001";
/// let this_library_node_name2 = "649349.Lbys_R0014";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leadbetterella_byssophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_leadbetterella_byssophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leadbetterella_byssophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leadbetterella_byssophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["649349"]),
        None,
        Some("."),
        Some("Lbys_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Truepera radiovictrix nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "649638.Trad_0001";
/// let this_library_node_name2 = "649638.Trad_R0039";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_truepera_radiovictrix_node_name(this_library_node_name1));
/// assert!(is_valid_string_truepera_radiovictrix_node_name(this_library_node_name2));
/// assert!(!is_valid_string_truepera_radiovictrix_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_truepera_radiovictrix_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["649638"]),
        None,
        Some("."),
        Some("Trad_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus cellulosilyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "649639.Bcell_0001";
/// let this_library_node_name2 = "649639.Bcell_4331";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_cellulosilyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_cellulosilyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_cellulosilyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_cellulosilyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["649639"]),
        None,
        Some("."),
        Some("Bcell_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. F0332 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "649743.HMPREF0972_00001";
/// let this_library_node_name2 = "649743.HMPREF0972_02645";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_f0332_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_f0332_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_f0332_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_f0332_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["649743"]),
        None,
        Some("."),
        Some("HMPREF0972_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aneurinibacillus aneurinilyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "649747.HMPREF0083_00001";
/// let this_library_node_name2 = "649747.HMPREF0083_06262";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aneurinibacillus_aneurinilyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_aneurinibacillus_aneurinilyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aneurinibacillus_aneurinilyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aneurinibacillus_aneurinilyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["649747"]),
        None,
        Some("."),
        Some("HMPREF0083_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium ammoniagenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "649754.HMPREF0281_00001";
/// let this_library_node_name2 = "649754.HMPREF0281_02703";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_ammoniagenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_ammoniagenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_ammoniagenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_ammoniagenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["649754"]),
        None,
        Some("."),
        Some("HMPREF0281_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella veroralis F0319 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "649761.HMPREF0973_00001";
/// let this_library_node_name2 = "649761.HMPREF0973_03111";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_veroralis_f0319_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_veroralis_f0319_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_veroralis_f0319_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_veroralis_f0319_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["649761"]),
        None,
        Some("."),
        Some("HMPREF0973_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Slackia exigua nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "649764.HMPREF0762_00001";
/// let this_library_node_name2 = "649764.HMPREF0762_02085";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_slackia_exigua_node_name(this_library_node_name1));
/// assert!(is_valid_string_slackia_exigua_node_name(this_library_node_name2));
/// assert!(!is_valid_string_slackia_exigua_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_slackia_exigua_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["649764"]),
        None,
        Some("."),
        Some("HMPREF0762_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinoplanes sp. N902109 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "649831.L083_0001";
/// let this_library_node_name2 = "649831.L083_8212";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinoplanes_sp_n902109_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinoplanes_sp_n902109_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinoplanes_sp_n902109_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinoplanes_sp_n902109_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["649831"]),
        None,
        Some("."),
        Some("L083_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erysipelothrix rhusiopathiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "650150.ERH_0001";
/// let this_library_node_name2 = "650150.ERH_1704";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erysipelothrix_rhusiopathiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_erysipelothrix_rhusiopathiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erysipelothrix_rhusiopathiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erysipelothrix_rhusiopathiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["650150"]),
        None,
        Some("."),
        Some("ERH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodopseudomonas palustris DX1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "652103.Rpdx1_0001";
/// let this_library_node_name2 = "652103.Rpdx1_5022";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodopseudomonas_palustris_dx1_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodopseudomonas_palustris_dx1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodopseudomonas_palustris_dx1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodopseudomonas_palustris_dx1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["652103"]),
        None,
        Some("."),
        Some("Rpdx1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces violaceusniger nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "653045.Strvi_0001";
/// let this_library_node_name2 = "653045.Strvi_9231";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_violaceusniger_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_violaceusniger_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_violaceusniger_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_violaceusniger_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["653045"]),
        None,
        Some("."),
        Some("Strvi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. F0330 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "653386.HMPREF0975_00001";
/// let this_library_node_name2 = "653386.HMPREF0975_03019";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_f0330_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_f0330_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_f0330_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_f0330_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["653386"]),
        None,
        Some("."),
        Some("HMPREF0975_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfurispirillum indicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "653733.Selin_0001";
/// let this_library_node_name2 = "653733.Selin_2619";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfurispirillum_indicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfurispirillum_indicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfurispirillum_indicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfurispirillum_indicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["653733"]),
        None,
        Some("."),
        Some("Selin_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Albugo laibachii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "653948.CCA13858";
/// let this_library_node_name2 = "653948.CCA28472";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_albugo_laibachii_node_name(this_library_node_name1));
/// assert!(is_valid_string_albugo_laibachii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_albugo_laibachii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_albugo_laibachii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["653948"]),
        None,
        Some("."),
        Some("CCA"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerococcus vaginalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "655811.HMPREF0078_0001";
/// let this_library_node_name2 = "655811.HMPREF0078_1766";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerococcus_vaginalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerococcus_vaginalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerococcus_vaginalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerococcus_vaginalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["655811"]),
        None,
        Some("."),
        Some("HMPREF0078_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aerococcus viridans ATCC11563 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "655812.HMPREF0061_0001";
/// let this_library_node_name2 = "655812.HMPREF0061_1929";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aerococcus_viridans_atcc11563_node_name(this_library_node_name1));
/// assert!(is_valid_string_aerococcus_viridans_atcc11563_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aerococcus_viridans_atcc11563_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aerococcus_viridans_atcc11563_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["655812"]),
        None,
        Some("."),
        Some("HMPREF0061_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus oralis ATCC35037 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "655813.HMPREF8579_0001";
/// let this_library_node_name2 = "655813.HMPREF8579_1847";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_oralis_atcc35037_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_oralis_atcc35037_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_oralis_atcc35037_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_oralis_atcc35037_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["655813"]),
        None,
        Some("."),
        Some("HMPREF8579_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zunongwangia profunda nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "655815.ZPR_0001";
/// let this_library_node_name2 = "655815.ZPR_4718";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zunongwangia_profunda_node_name(this_library_node_name1));
/// assert!(is_valid_string_zunongwangia_profunda_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zunongwangia_profunda_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zunongwangia_profunda_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["655815"]),
        None,
        Some("."),
        Some("ZPR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudogymnoascus destructans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "655981.L8FL39";
/// let this_library_node_name2 = "655981.L8GF18";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudogymnoascus_destructans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudogymnoascus_destructans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudogymnoascus_destructans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudogymnoascus_destructans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["655981"]),
        None,
        Some("."),
        Some("L8"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frankia symbiont nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "656024.FsymDg_0001";
/// let this_library_node_name2 = "656024.FsymDg_4559";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frankia_symbiont_node_name(this_library_node_name1));
/// assert!(is_valid_string_frankia_symbiont_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frankia_symbiont_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frankia_symbiont_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["656024"]),
        None,
        Some("."),
        Some("FsymDg_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halanaerobium hydrogeniformans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "656519.Halsa_0001";
/// let this_library_node_name2 = "656519.Halsa_2391";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halanaerobium_hydrogeniformans_node_name(this_library_node_name1));
/// assert!(is_valid_string_halanaerobium_hydrogeniformans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halanaerobium_hydrogeniformans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halanaerobium_hydrogeniformans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["656519"]),
        None,
        Some("."),
        Some("Halsa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides xylanisolvens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "657309.BXY_00100";
/// let this_library_node_name2 = "657309.BXY_48820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_xylanisolvens_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_xylanisolvens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_xylanisolvens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_xylanisolvens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["657309"]),
        None,
        Some("."),
        Some("BXY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Faecalibacterium prausnitzii SL33 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "657322.FPR_00100";
/// let this_library_node_name2 = "657322.FPR_31730";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_faecalibacterium_prausnitzii_sl33_node_name(this_library_node_name1));
/// assert!(is_valid_string_faecalibacterium_prausnitzii_sl33_node_name(this_library_node_name2));
/// assert!(!is_valid_string_faecalibacterium_prausnitzii_sl33_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_faecalibacterium_prausnitzii_sl33_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["657322"]),
        None,
        Some("."),
        Some("FPR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium 3157FAACT1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "658086.HMPREF0994_00001";
/// let this_library_node_name2 = "658086.HMPREF0994_07323";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_3157faact1_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_3157faact1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_3157faact1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_3157faact1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["658086"]),
        None,
        Some("."),
        Some("HMPREF0994_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium 9143BFAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "658088.HMPREF0987_00001";
/// let this_library_node_name2 = "658088.HMPREF0987_02720";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_9143bfaa_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_9143bfaa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_9143bfaa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_9143bfaa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["658088"]),
        None,
        Some("."),
        Some("HMPREF0987_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Liberibacter solanacearum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "658172.CKC_00005";
/// let this_library_node_name2 = "658172.CKC_05990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_liberibacter_solanacearum_node_name(this_library_node_name1));
/// assert!(is_valid_string_liberibacter_solanacearum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_liberibacter_solanacearum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_liberibacter_solanacearum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["658172"]),
        None,
        Some("."),
        Some("CKC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella drancourtii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "658187.LDG_5001";
/// let this_library_node_name2 = "658187.LDG_9105";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_drancourtii_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_drancourtii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_drancourtii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_drancourtii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["658187"]),
        None,
        Some("."),
        Some("LDG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. H2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "658612.MD26_00005";
/// let this_library_node_name2 = "658612.MD26_25765";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_h2_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_h2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_h2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_h2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["658612"]),
        None,
        Some("."),
        Some("MD26_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium 1456FAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "658655.HMPREF0988_00001";
/// let this_library_node_name2 = "658655.HMPREF0988_03191";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_1456faa_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_1456faa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_1456faa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_1456faa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["658655"]),
        None,
        Some("."),
        Some("HMPREF0988_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erysipelotrichaceae bacterium 3153 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "658659.HMPREF0983_00001";
/// let this_library_node_name2 = "658659.HMPREF0983_04217";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erysipelotrichaceae_bacterium_3153_node_name(this_library_node_name1));
/// assert!(is_valid_string_erysipelotrichaceae_bacterium_3153_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erysipelotrichaceae_bacterium_3153_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erysipelotrichaceae_bacterium_3153_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["658659"]),
        None,
        Some("."),
        Some("HMPREF0983_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesotoga prima nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "660470.Theba_0001";
/// let this_library_node_name2 = "660470.Theba_2738";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesotoga_prima_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesotoga_prima_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesotoga_prima_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesotoga_prima_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["660470"]),
        None,
        Some("."),
        Some("Theba_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Olsenella sp. F0356 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "661087.HMPREF1008_00001";
/// let this_library_node_name2 = "661087.HMPREF1008_01898";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_olsenella_sp_f0356_node_name(this_library_node_name1));
/// assert!(is_valid_string_olsenella_sp_f0356_node_name(this_library_node_name2));
/// assert!(!is_valid_string_olsenella_sp_f0356_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_olsenella_sp_f0356_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["661087"]),
        None,
        Some("."),
        Some("HMPREF1008_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella longbeachae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "661367.LLO_0001";
/// let this_library_node_name2 = "661367.LLO_p4100";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_longbeachae_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_longbeachae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_longbeachae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_longbeachae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["661367"]),
        None,
        Some("."),
        Some("LLO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fimbriimonas ginsengisoli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "661478.OP10G_0001";
/// let this_library_node_name2 = "661478.OP10G_4820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fimbriimonas_ginsengisoli_node_name(this_library_node_name1));
/// assert!(is_valid_string_fimbriimonas_ginsengisoli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fimbriimonas_ginsengisoli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fimbriimonas_ginsengisoli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["661478"]),
        None,
        Some("."),
        Some("OP10G_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloferax mucosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "662479.C440_00005";
/// let this_library_node_name2 = "662479.C440_17141";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloferax_mucosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloferax_mucosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloferax_mucosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloferax_mucosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["662479"]),
        None,
        Some("."),
        Some("C440_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium resistens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "662755.CRES_0001";
/// let this_library_node_name2 = "662755.CRES_2185";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_resistens_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_resistens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_resistens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_resistens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["662755"]),
        None,
        Some("."),
        Some("CRES_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ethanoligenens harbinense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "663278.Ethha_0001";
/// let this_library_node_name2 = "663278.Ethha_2800";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ethanoligenens_harbinense_node_name(this_library_node_name1));
/// assert!(is_valid_string_ethanoligenens_harbinense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ethanoligenens_harbinense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ethanoligenens_harbinense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["663278"]),
        None,
        Some("."),
        Some("Ethha_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Regiella insecticola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "663321.REG_0001";
/// let this_library_node_name2 = "663321.REG_p0030";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_regiella_insecticola_node_name(this_library_node_name1));
/// assert!(is_valid_string_regiella_insecticola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_regiella_insecticola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_regiella_insecticola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["663321"]),
        None,
        Some("."),
        Some("REG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylocapsa aurea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "663610.JQKO01000001_gene1000";
/// let this_library_node_name2 = "663610.JQKO01000037_gene505";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylocapsa_aurea_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylocapsa_aurea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylocapsa_aurea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylocapsa_aurea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["663610"]),
        None,
        Some("."),
        Some("JQKO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetobacter aceti ATCC23746 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "663932.KB902575_gene100";
/// let this_library_node_name2 = "663932.KB902577_gene4";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetobacter_aceti_atcc23746_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetobacter_aceti_atcc23746_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetobacter_aceti_atcc23746_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetobacter_aceti_atcc23746_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["663932"]),
        None,
        Some("."),
        Some("KB90257"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus dysgalactiae ATCC27957 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "663952.SDD27957_00005";
/// let this_library_node_name2 = "663952.SDD27957_11210";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_dysgalactiae_atcc27957_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_dysgalactiae_atcc27957_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_dysgalactiae_atcc27957_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_dysgalactiae_atcc27957_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["663952"]),
        None,
        Some("."),
        Some("SDD27957_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erwinia amylovora nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "665029.EAMY_0001";
/// let this_library_node_name2 = "665029.EAMY_3740";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erwinia_amylovora_node_name(this_library_node_name1));
/// assert!(is_valid_string_erwinia_amylovora_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erwinia_amylovora_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erwinia_amylovora_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["665029"]),
        None,
        Some("."),
        Some("EAMY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirochaeta thermophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "665571.STHERM_c00010";
/// let this_library_node_name2 = "665571.STHERM_c22570";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirochaeta_thermophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirochaeta_thermophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirochaeta_thermophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirochaeta_thermophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["665571"]),
        None,
        Some("."),
        Some("STHERM_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces viridosporus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "665577.JH993787_gene7255";
/// let this_library_node_name2 = "665577.JH993792_gene7262";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_viridosporus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_viridosporus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_viridosporus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_viridosporus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["665577"]),
        None,
        Some("."),
        Some("JH9937"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio sp. 6146AFAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "665942.HMPREF1022_00001";
/// let this_library_node_name2 = "665942.HMPREF1022_03326";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_sp_6146afaa_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_sp_6146afaa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_sp_6146afaa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_sp_6146afaa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["665942"]),
        None,
        Some("."),
        Some("HMPREF1022_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium 3146FAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "665950.HMPREF1025_00001";
/// let this_library_node_name2 = "665950.HMPREF1025_02940";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_3146faa_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_3146faa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_3146faa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_3146faa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["665950"]),
        None,
        Some("."),
        Some("HMPREF1025_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus smithii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "665952.HMPREF1015_00001";
/// let this_library_node_name2 = "665952.HMPREF1015_03294";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_smithii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_smithii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_smithii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_smithii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["665952"]),
        None,
        Some("."),
        Some("HMPREF1015_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Subdoligranulum sp. 4354A2FAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "665956.HMPREF1032_00001";
/// let this_library_node_name2 = "665956.HMPREF1032_04105";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_subdoligranulum_sp_4354a2faa_node_name(this_library_node_name1));
/// assert!(is_valid_string_subdoligranulum_sp_4354a2faa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_subdoligranulum_sp_4354a2faa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_subdoligranulum_sp_4354a2faa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["665956"]),
        None,
        Some("."),
        Some("HMPREF1032_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. 2A57CT2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "665959.HMPREF1013_00001";
/// let this_library_node_name2 = "665959.HMPREF1013_05792";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_2a57ct2_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_2a57ct2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_2a57ct2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_2a57ct2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["665959"]),
        None,
        Some("."),
        Some("HMPREF1013_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Planktomarina temperata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "666509.RCA23_c00010";
/// let this_library_node_name2 = "666509.RCA23_c31060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_planktomarina_temperata_node_name(this_library_node_name1));
/// assert!(is_valid_string_planktomarina_temperata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_planktomarina_temperata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_planktomarina_temperata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["666509"]),
        None,
        Some("."),
        Some("RCA23_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidilobus saccharovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "666510.ASAC_0001";
/// let this_library_node_name2 = "666510.ASAC_1503";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidilobus_saccharovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidilobus_saccharovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidilobus_saccharovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidilobus_saccharovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["666510"]),
        None,
        Some("."),
        Some("ASAC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylotenera versatilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "666681.M301_0001";
/// let this_library_node_name2 = "666681.M301_2801";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylotenera_versatilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylotenera_versatilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylotenera_versatilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylotenera_versatilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["666681"]),
        None,
        Some("."),
        Some("M301_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Afipia sp. 1NLS2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "666684.AfiDRAFT_0001";
/// let this_library_node_name2 = "666684.AfiDRAFT_3825";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_afipia_sp_1nls2_node_name(this_library_node_name1));
/// assert!(is_valid_string_afipia_sp_1nls2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_afipia_sp_1nls2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_afipia_sp_1nls2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["666684"]),
        None,
        Some("."),
        Some("AfiDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodanobacter denitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "666685.R2APBS1_0001";
/// let this_library_node_name2 = "666685.R2APBS1_3962";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodanobacter_denitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodanobacter_denitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodanobacter_denitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodanobacter_denitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["666685"]),
        None,
        Some("."),
        Some("R2APBS1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. 1NLA3E nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "666686.B1NLA3E_00005";
/// let this_library_node_name2 = "666686.B1NLA3E_22290";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_1nla3e_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_1nla3e_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_1nla3e_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_1nla3e_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["666686"]),
        None,
        Some("."),
        Some("B1NLA3E_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermodesulfatator indicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "667014.Thein_0001";
/// let this_library_node_name2 = "667014.Thein_R0030";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermodesulfatator_indicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermodesulfatator_indicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermodesulfatator_indicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermodesulfatator_indicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["667014"]),
        None,
        Some("."),
        Some("Thein_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides salanitronis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "667015.Bacsa_0001";
/// let this_library_node_name2 = "667015.Bacsa_3729";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_salanitronis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_salanitronis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_salanitronis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_salanitronis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["667015"]),
        None,
        Some("."),
        Some("Bacsa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Edwardsiella tarda ATCC15947 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "667121.ET1_01_00010";
/// let this_library_node_name2 = "667121.ET1_34_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_edwardsiella_tarda_atcc15947_node_name(this_library_node_name1));
/// assert!(is_valid_string_edwardsiella_tarda_atcc15947_node_name(this_library_node_name2));
/// assert!(!is_valid_string_edwardsiella_tarda_atcc15947_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_edwardsiella_tarda_atcc15947_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["667121"]),
        None,
        Some("."),
        Some("ET1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sp. JPY347 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "667632.KB890164_gene1632";
/// let this_library_node_name2 = "667632.KB890220_gene2882";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sp_jpy347_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sp_jpy347_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sp_jpy347_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sp_jpy347_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["667632"]),
        None,
        Some("."),
        Some("KB890"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mannheimia haemolytica BOVINE nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "669262.COK_0003";
/// let this_library_node_name2 = "669262.COK_2602";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mannheimia_haemolytica_bovine_node_name(this_library_node_name1));
/// assert!(is_valid_string_mannheimia_haemolytica_bovine_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mannheimia_haemolytica_bovine_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mannheimia_haemolytica_bovine_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["669262"]),
        None,
        Some("."),
        Some("COK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Profftella armatura nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "669502.SSDC_00005";
/// let this_library_node_name2 = "669502.SSDC_01895";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_profftella_armatura_node_name(this_library_node_name1));
/// assert!(is_valid_string_profftella_armatura_node_name(this_library_node_name2));
/// assert!(!is_valid_string_profftella_armatura_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_profftella_armatura_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["669502"]),
        None,
        Some("."),
        Some("SSDC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microvirga aerilata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "670292.JH26_00005";
/// let this_library_node_name2 = "670292.JH26_28540";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microvirga_aerilata_node_name(this_library_node_name1));
/// assert!(is_valid_string_microvirga_aerilata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microvirga_aerilata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microvirga_aerilata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["670292"]),
        None,
        Some("."),
        Some("JH26_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomicrobium denitrificans 1NES1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "670307.HYPDE_22543";
/// let this_library_node_name2 = "670307.HYPDE_41848";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomicrobium_denitrificans_1nes1_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomicrobium_denitrificans_1nes1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomicrobium_denitrificans_1nes1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomicrobium_denitrificans_1nes1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["670307"]),
        None,
        Some("."),
        Some("HYPDE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanithermus profundus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "670487.Ocepr_0001";
/// let this_library_node_name2 = "670487.Ocepr_2391";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanithermus_profundus_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanithermus_profundus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanithermus_profundus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanithermus_profundus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["670487"]),
        None,
        Some("."),
        Some("Ocepr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Metallosphaera yellowstonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "671065.MetMK1DRAFT_00000010";
/// let this_library_node_name2 = "671065.MetMK1DRAFT_00034110";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_metallosphaera_yellowstonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_metallosphaera_yellowstonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_metallosphaera_yellowstonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_metallosphaera_yellowstonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["671065"]),
        None,
        Some("."),
        Some("MetMK1DRAFT_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylomirabilis oxyfera nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "671143.DAMO_0001";
/// let this_library_node_name2 = "671143.DAMO_3175";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylomirabilis_oxyfera_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylomirabilis_oxyfera_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylomirabilis_oxyfera_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylomirabilis_oxyfera_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["671143"]),
        None,
        Some("."),
        Some("DAMO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aciduliprofundum sp. MAR08339 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "673860.AciM339_0001";
/// let this_library_node_name2 = "673860.AciM339_1580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aciduliprofundum_sp_mar08339_node_name(this_library_node_name1));
/// assert!(is_valid_string_aciduliprofundum_sp_mar08339_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aciduliprofundum_sp_mar08339_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aciduliprofundum_sp_mar08339_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["673860"]),
        None,
        Some("."),
        Some("AciM339_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Babela massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "673862.BABL1_00981";
/// let this_library_node_name2 = "673862.BABL1_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_babela_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_babela_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_babela_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_babela_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["673862"]),
        None,
        Some("."),
        Some("BABL1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio alginolyticus 40B nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "674977.VMC_00010";
/// let this_library_node_name2 = "674977.VMC_43370";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_alginolyticus_40b_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_alginolyticus_40b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_alginolyticus_40b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_alginolyticus_40b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["674977"]),
        None,
        Some("."),
        Some("VMC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudonocardia dioxanivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "675635.Psed_0001";
/// let this_library_node_name2 = "675635.Psed_6882";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudonocardia_dioxanivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudonocardia_dioxanivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudonocardia_dioxanivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudonocardia_dioxanivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["675635"]),
        None,
        Some("."),
        Some("Psed_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio mimicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "675806.VII_000001";
/// let this_library_node_name2 = "675806.VII_003803";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_mimicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_mimicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_mimicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_mimicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["675806"]),
        None,
        Some("."),
        Some("VII_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Grimontia hollisae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "675812.VHA_000001";
/// let this_library_node_name2 = "675812.VHA_003583";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_grimontia_hollisae_node_name(this_library_node_name1));
/// assert!(is_valid_string_grimontia_hollisae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_grimontia_hollisae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_grimontia_hollisae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["675812"]),
        None,
        Some("."),
        Some("VHA_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio metschnikovii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "675813.VIB_000001";
/// let this_library_node_name2 = "675813.VIB_003109";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_metschnikovii_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_metschnikovii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_metschnikovii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_metschnikovii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["675813"]),
        None,
        Some("."),
        Some("VIB_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio coralliilyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "675814.VIC_000001";
/// let this_library_node_name2 = "675814.VIC_005078";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_coralliilyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_coralliilyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_coralliilyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_coralliilyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["675814"]),
        None,
        Some("."),
        Some("VIC_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio sp. RC586 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "675815.VOA_000001";
/// let this_library_node_name2 = "675815.VOA_003592";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_sp_rc586_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_sp_rc586_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_sp_rc586_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_sp_rc586_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["675815"]),
        None,
        Some("."),
        Some("VOA_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio orientalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "675816.VIA_000001";
/// let this_library_node_name2 = "675816.VIA_004179";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_orientalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_orientalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_orientalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_orientalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["675816"]),
        None,
        Some("."),
        Some("VIA_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photobacterium damselae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "675817.VDA_000001";
/// let this_library_node_name2 = "675817.VDA_003545";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photobacterium_damselae_node_name(this_library_node_name1));
/// assert!(is_valid_string_photobacterium_damselae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photobacterium_damselae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photobacterium_damselae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["675817"]),
        None,
        Some("."),
        Some("VDA_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Francisella tularensis novicida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "676032.FN3523_0001";
/// let this_library_node_name2 = "676032.FN3523_1854";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_francisella_tularensis_novicida_node_name(this_library_node_name1));
/// assert!(is_valid_string_francisella_tularensis_novicida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_francisella_tularensis_novicida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_francisella_tularensis_novicida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["676032"]),
        None,
        Some("."),
        Some("FN3523_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella timonensis CRIS5CB1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679189.HMPREF9019_0001";
/// let this_library_node_name2 = "679189.HMPREF9019_2271";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_timonensis_cris5cb1_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_timonensis_cris5cb1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_timonensis_cris5cb1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_timonensis_cris5cb1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679189"]),
        None,
        Some("."),
        Some("HMPREF9019_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella buccalis ATCC35310 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679190.HMPREF0650_0002";
/// let this_library_node_name2 = "679190.HMPREF0650_2515";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_buccalis_atcc35310_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_buccalis_atcc35310_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_buccalis_atcc35310_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_buccalis_atcc35310_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679190"]),
        None,
        Some("."),
        Some("HMPREF0650_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella amnii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679191.HMPREF9018_0001";
/// let this_library_node_name2 = "679191.HMPREF9018_2081";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_amnii_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_amnii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_amnii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_amnii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679191"]),
        None,
        Some("."),
        Some("HMPREF9018_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bulleidia extructa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679192.HMPREF9013_0001";
/// let this_library_node_name2 = "679192.HMPREF9013_1479";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bulleidia_extructa_node_name(this_library_node_name1));
/// assert!(is_valid_string_bulleidia_extructa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bulleidia_extructa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bulleidia_extructa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679192"]),
        None,
        Some("."),
        Some("HMPREF9013_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Segniliparus rugosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679197.HMPREF9336_00001";
/// let this_library_node_name2 = "679197.HMPREF9336_04382";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_segniliparus_rugosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_segniliparus_rugosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_segniliparus_rugosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_segniliparus_rugosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679197"]),
        None,
        Some("."),
        Some("HMPREF9336_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alloprevotella rava nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679199.HMPREF9332_00001";
/// let this_library_node_name2 = "679199.HMPREF9332_02014";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alloprevotella_rava_node_name(this_library_node_name1));
/// assert!(is_valid_string_alloprevotella_rava_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alloprevotella_rava_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alloprevotella_rava_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679199"]),
        None,
        Some("."),
        Some("HMPREF9332_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Johnsonella ignava nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679200.HMPREF9333_00001";
/// let this_library_node_name2 = "679200.HMPREF9333_02315";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_johnsonella_ignava_node_name(this_library_node_name1));
/// assert!(is_valid_string_johnsonella_ignava_node_name(this_library_node_name2));
/// assert!(!is_valid_string_johnsonella_ignava_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_johnsonella_ignava_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679200"]),
        None,
        Some("."),
        Some("HMPREF9333_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas infelix nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679201.HMPREF9334_00001";
/// let this_library_node_name2 = "679201.HMPREF9334_02164";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_infelix_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_infelix_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_infelix_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_infelix_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679201"]),
        None,
        Some("."),
        Some("HMPREF9334_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter mustelae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679897.HMU00010";
/// let this_library_node_name2 = "679897.HMU14440";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_mustelae_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_mustelae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_mustelae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_mustelae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679897"]),
        None,
        Some("."),
        Some("HMU"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanoplanus petrolearius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679926.Mpet_0001";
/// let this_library_node_name2 = "679926.Mpet_2824";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanoplanus_petrolearius_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanoplanus_petrolearius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanoplanus_petrolearius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanoplanus_petrolearius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679926"]),
        None,
        Some("."),
        Some("Mpet_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alistipes finegoldii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679935.Alfi_0001";
/// let this_library_node_name2 = "679935.Alfi_3304";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alistipes_finegoldii_node_name(this_library_node_name1));
/// assert!(is_valid_string_alistipes_finegoldii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alistipes_finegoldii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alistipes_finegoldii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679935"]),
        None,
        Some("."),
        Some("Alfi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides coprosuis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "679937.Bcop_0001";
/// let this_library_node_name2 = "679937.Bcop_R0067";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_coprosuis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_coprosuis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_coprosuis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_coprosuis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["679937"]),
        None,
        Some("."),
        Some("Bcop_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces scabiei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "680198.SCAB_0021";
/// let this_library_node_name2 = "680198.SCAB_9991";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_scabiei_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_scabiei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_scabiei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_scabiei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["680198"]),
        None,
        Some("."),
        Some("SCAB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rothia mucilaginosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "680646.RMDY18_00010";
/// let this_library_node_name2 = "680646.RMDY18_19920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rothia_mucilaginosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_rothia_mucilaginosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rothia_mucilaginosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rothia_mucilaginosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["680646"]),
        None,
        Some("."),
        Some("RMDY18_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Granulicella mallensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "682795.AciX8_0001";
/// let this_library_node_name2 = "682795.AciX8_4907";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_granulicella_mallensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_granulicella_mallensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_granulicella_mallensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_granulicella_mallensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["682795"]),
        None,
        Some("."),
        Some("AciX8_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter jejuni 414 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "683083.C414_000010000";
/// let this_library_node_name2 = "683083.C414_000470014";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_jejuni_414_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_jejuni_414_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_jejuni_414_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_jejuni_414_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["683083"]),
        None,
        Some("."),
        Some("C414_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeria seeligeri 12b nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "683837.lse_0001";
/// let this_library_node_name2 = "683837.lse_2722";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeria_seeligeri_12b_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeria_seeligeri_12b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeria_seeligeri_12b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeria_seeligeri_12b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["683837"]),
        None,
        Some("."),
        Some("lse_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING alpha proteobacterium HIMB114 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "684719.HIMB114_00000010";
/// let this_library_node_name2 = "684719.HIMB114_00013570";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alpha_proteobacterium_himb114_node_name(this_library_node_name1));
/// assert!(is_valid_string_alpha_proteobacterium_himb114_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alpha_proteobacterium_himb114_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alpha_proteobacterium_himb114_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["684719"]),
        None,
        Some("."),
        Some("HIMB114_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus sp. 2009 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "684949.ATTJ01000001_gene1000";
/// let this_library_node_name2 = "684949.ATTJ01000006_gene446";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_sp_2009_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_sp_2009_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_sp_2009_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_sp_2009_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["684949"]),
        None,
        Some("."),
        Some("ATTJ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citromicrobium bathyomarinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "685035.ADAE01000001_gene3085";
/// let this_library_node_name2 = "685035.ADAE01000068_gene1553";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citromicrobium_bathyomarinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_citromicrobium_bathyomarinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citromicrobium_bathyomarinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citromicrobium_bathyomarinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["685035"]),
        None,
        Some("."),
        Some("ADAE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus equi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "685727.REQ_00010";
/// let this_library_node_name2 = "685727.REQ_47450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_equi_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_equi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_equi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_equi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["685727"]),
        None,
        Some("."),
        Some("REQ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. PR090111T3T6A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "685778.AORL01000001_gene131";
/// let this_library_node_name2 = "685778.AORL01000025_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_pr090111t3t6a_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_pr090111t3t6a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_pr090111t3t6a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_pr090111t3t6a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["685778"]),
        None,
        Some("."),
        Some("AORL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella rochalimae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "685782.O99_00001";
/// let this_library_node_name2 = "685782.O99_01298";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_rochalimae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_rochalimae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_rochalimae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_rochalimae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["685782"]),
        None,
        Some("."),
        Some("O99_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylomicrobium album nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "686340.Metal_0001";
/// let this_library_node_name2 = "686340.Metal_4042";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylomicrobium_album_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylomicrobium_album_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylomicrobium_album_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylomicrobium_album_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["686340"]),
        None,
        Some("."),
        Some("Metal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. S9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "686578.AFFX01000001_gene1013";
/// let this_library_node_name2 = "686578.AFFX01000025_gene1953";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_s9_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_s9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_s9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_s9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["686578"]),
        None,
        Some("."),
        Some("AFFX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Comamonas testosteroni CNB2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "688245.CtCNB1_0001";
/// let this_library_node_name2 = "688245.CtCNB1_4803";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_comamonas_testosteroni_cnb2_node_name(this_library_node_name1));
/// assert!(is_valid_string_comamonas_testosteroni_cnb2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_comamonas_testosteroni_cnb2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_comamonas_testosteroni_cnb2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["688245"]),
        None,
        Some("."),
        Some("CtCNB1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella multisaccharivorax nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "688246.Premu_0002";
/// let this_library_node_name2 = "688246.Premu_R0065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_multisaccharivorax_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_multisaccharivorax_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_multisaccharivorax_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_multisaccharivorax_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["688246"]),
        None,
        Some("."),
        Some("Premu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermotoga thermarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "688269.Theth_0001";
/// let this_library_node_name2 = "688269.Theth_2015";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermotoga_thermarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermotoga_thermarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermotoga_thermarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermotoga_thermarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["688269"]),
        None,
        Some("."),
        Some("Theth_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellulophaga algicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "688270.Celal_0001";
/// let this_library_node_name2 = "688270.Celal_R0010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellulophaga_algicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellulophaga_algicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellulophaga_algicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellulophaga_algicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["688270"]),
        None,
        Some("."),
        Some("Celal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oribacterium sp. NK2B42 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "689781.AUJX01000001_gene2726";
/// let this_library_node_name2 = "689781.AUJX01000102_gene2583";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oribacterium_sp_nk2b42_node_name(this_library_node_name1));
/// assert!(is_valid_string_oribacterium_sp_nk2b42_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oribacterium_sp_nk2b42_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oribacterium_sp_nk2b42_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["689781"]),
        None,
        Some("."),
        Some("AUJX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium vignae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "690585.JNNU01000001_gene1";
/// let this_library_node_name2 = "690585.JNNU01000083_gene1066";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_vignae_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_vignae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_vignae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_vignae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["690585"]),
        None,
        Some("."),
        Some("JNNU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas fluorescens NZ007 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "690597.JH730912_gene5000";
/// let this_library_node_name2 = "690597.JH730989_gene3082";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_fluorescens_nz007_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_fluorescens_nz007_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_fluorescens_nz007_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_fluorescens_nz007_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["690597"]),
        None,
        Some("."),
        Some("JH7309"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio africanus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "690850.Desaf_0001";
/// let this_library_node_name2 = "690850.Desaf_3815";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_africanus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_africanus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_africanus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_africanus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["690850"]),
        None,
        Some("."),
        Some("Desaf_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fonticula alba nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "691883.XP_009492117.1";
/// let this_library_node_name2 = "691883.XP_009498405.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fonticula_alba_node_name(this_library_node_name1));
/// assert!(is_valid_string_fonticula_alba_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fonticula_alba_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fonticula_alba_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["691883"]),
        None,
        Some("."),
        Some("XP_00949"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacteriaceae bacterium strain nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "693444.D782_0001";
/// let this_library_node_name2 = "693444.D782_4549";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacteriaceae_bacterium_strain_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacteriaceae_bacterium_strain_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacteriaceae_bacterium_strain_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacteriaceae_bacterium_strain_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["693444"]),
        None,
        Some("."),
        Some("D782_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Archaeoglobus veneficus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "693661.Arcve_0001";
/// let this_library_node_name2 = "693661.Arcve_2145";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_archaeoglobus_veneficus_node_name(this_library_node_name1));
/// assert!(is_valid_string_archaeoglobus_veneficus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_archaeoglobus_veneficus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_archaeoglobus_veneficus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["693661"]),
        None,
        Some("."),
        Some("Arcve_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oscillibacter valericigenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "693746.OBV_00010";
/// let this_library_node_name2 = "693746.OBV_p-00670";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oscillibacter_valericigenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_oscillibacter_valericigenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oscillibacter_valericigenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oscillibacter_valericigenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["693746"]),
        None,
        Some("."),
        Some("OBV_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus proteolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "693977.Deipr_0001";
/// let this_library_node_name2 = "693977.Deipr_2631";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_proteolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_proteolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_proteolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_proteolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["693977"]),
        None,
        Some("."),
        Some("Deipr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides helcogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "693979.Bache_0001";
/// let this_library_node_name2 = "693979.Bache_R0042";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_helcogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_helcogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_helcogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_helcogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["693979"]),
        None,
        Some("."),
        Some("Bache_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium oryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "693986.MOC_0001";
/// let this_library_node_name2 = "693986.MOC_6274";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_oryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_oryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_oryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_oryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["693986"]),
        None,
        Some("."),
        Some("MOC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paludibacter propionicigenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "694427.Palpr_0001";
/// let this_library_node_name2 = "694427.Palpr_3054";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paludibacter_propionicigenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_paludibacter_propionicigenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paludibacter_propionicigenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paludibacter_propionicigenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["694427"]),
        None,
        Some("."),
        Some("Palpr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrolobus fumarii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "694429.Pyrfu_0001";
/// let this_library_node_name2 = "694429.Pyrfu_1986";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrolobus_fumarii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrolobus_fumarii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrolobus_fumarii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrolobus_fumarii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["694429"]),
        None,
        Some("."),
        Some("Pyrfu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natronococcus occultus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "694430.Natoc_0001";
/// let this_library_node_name2 = "694430.Natoc_4076";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natronococcus_occultus_node_name(this_library_node_name1));
/// assert!(is_valid_string_natronococcus_occultus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natronococcus_occultus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natronococcus_occultus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["694430"]),
        None,
        Some("."),
        Some("Natoc_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfurella acetivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "694431.DESACE_00005";
/// let this_library_node_name2 = "694431.DESACE_09645";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfurella_acetivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfurella_acetivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfurella_acetivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfurella_acetivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["694431"]),
        None,
        Some("."),
        Some("DESACE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanomicrobium mobile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "694440.JOMF01000002_gene1082";
/// let this_library_node_name2 = "694440.JOMF01000012_gene1085";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanomicrobium_mobile_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanomicrobium_mobile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanomicrobium_mobile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanomicrobium_mobile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["694440"]),
        None,
        Some("."),
        Some("JOMF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aggregatibacter actinomycetemcomitans D7S1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "694569.D7S_00002";
/// let this_library_node_name2 = "694569.D7S_02450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aggregatibacter_actinomycetemcomitans_d7s1_node_name(this_library_node_name1));
/// assert!(is_valid_string_aggregatibacter_actinomycetemcomitans_d7s1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aggregatibacter_actinomycetemcomitans_d7s1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aggregatibacter_actinomycetemcomitans_d7s1_node_name(
    node_name: &str,
) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["694569"]),
        None,
        Some("."),
        Some("D7S_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella clarridgeiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "696125.BARCL_0001";
/// let this_library_node_name2 = "696125.BARCL_1395";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_clarridgeiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_clarridgeiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_clarridgeiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_clarridgeiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["696125"]),
        None,
        Some("."),
        Some("BARCL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum ruminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "696281.Desru_0001";
/// let this_library_node_name2 = "696281.Desru_3903";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_ruminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_ruminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_ruminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_ruminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["696281"]),
        None,
        Some("."),
        Some("Desru_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum nigrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "696369.KI912183_gene1";
/// let this_library_node_name2 = "696369.KI912183_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_nigrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_nigrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_nigrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_nigrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["696369"]),
        None,
        Some("."),
        Some("KI912183_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrospira platensis NIES39 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "696747.NIES39_A00010";
/// let this_library_node_name2 = "696747.NIES39_R01620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrospira_platensis_nies39_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrospira_platensis_nies39_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrospira_platensis_nies39_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrospira_platensis_nies39_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["696747"]),
        None,
        Some("."),
        Some("NIES39_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobacillus suis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "696748.ASU2_00005";
/// let this_library_node_name2 = "696748.ASU2_11330";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobacillus_suis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobacillus_suis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobacillus_suis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobacillus_suis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["696748"]),
        None,
        Some("."),
        Some("ASU2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mahella australiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "697281.Mahau_0001";
/// let this_library_node_name2 = "697281.Mahau_R0048";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mahella_australiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mahella_australiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mahella_australiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mahella_australiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["697281"]),
        None,
        Some("."),
        Some("Mahau_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacter tundripaludum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "697282.Mettu_0001";
/// let this_library_node_name2 = "697282.Mettu_4410";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacter_tundripaludum_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacter_tundripaludum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacter_tundripaludum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacter_tundripaludum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["697282"]),
        None,
        Some("."),
        Some("Mettu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus larvae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "697284.ERIC2_c00010";
/// let this_library_node_name2 = "697284.ERIC2_c41290";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_larvae_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_larvae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_larvae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_larvae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["697284"]),
        None,
        Some("."),
        Some("ERIC2_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoanaerobacter wiegelii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "697303.Thewi_0001";
/// let this_library_node_name2 = "697303.Thewi_2723";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoanaerobacter_wiegelii_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoanaerobacter_wiegelii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoanaerobacter_wiegelii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoanaerobacter_wiegelii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["697303"]),
        None,
        Some("."),
        Some("Thewi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus albus 7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "697329.Rumal_0001";
/// let this_library_node_name2 = "697329.Rumal_3682";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_albus_7_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_albus_7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_albus_7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_albus_7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["697329"]),
        None,
        Some("."),
        Some("Rumal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marssonina brunnea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "698440.XP_007287890.1";
/// let this_library_node_name2 = "698440.XP_007297916.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marssonina_brunnea_node_name(this_library_node_name1));
/// assert!(is_valid_string_marssonina_brunnea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marssonina_brunnea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marssonina_brunnea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["698440"]),
        None,
        Some("."),
        Some("XP_0072"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus lugdunensis HKU0901 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "698737.SLGD_00001";
/// let this_library_node_name2 = "698737.SLGD_02575";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_lugdunensis_hku0901_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_lugdunensis_hku0901_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_lugdunensis_hku0901_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_lugdunensis_hku0901_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["698737"]),
        None,
        Some("."),
        Some("SLGD_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrobaculum oguniense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "698757.Pogu_0001";
/// let this_library_node_name2 = "698757.Pogu_ECE035";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrobaculum_oguniense_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrobaculum_oguniense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrobaculum_oguniense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrobaculum_oguniense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["698757"]),
        None,
        Some("."),
        Some("Pogu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amphibacillus xylanus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "698758.AXY_00010";
/// let this_library_node_name2 = "698758.AXY_24110";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amphibacillus_xylanus_node_name(this_library_node_name1));
/// assert!(is_valid_string_amphibacillus_xylanus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amphibacillus_xylanus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amphibacillus_xylanus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["698758"]),
        None,
        Some("."),
        Some("AXY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium tropici nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "698761.RTCIAT899_CH00005";
/// let this_library_node_name2 = "698761.RTCIAT899_CH18725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_tropici_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_tropici_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_tropici_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_tropici_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["698761"]),
        None,
        Some("."),
        Some("RTCIAT899_CH"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Virgibacillus alimentarius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "698769.JFBD01000001_gene2795";
/// let this_library_node_name2 = "698769.JFBD01000146_gene2718";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_virgibacillus_alimentarius_node_name(this_library_node_name1));
/// assert!(is_valid_string_virgibacillus_alimentarius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_virgibacillus_alimentarius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_virgibacillus_alimentarius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["698769"]),
        None,
        Some("."),
        Some("JFBD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gardnerella vaginalis 6119V5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "698961.CGSMWGv6119V5_00005";
/// let this_library_node_name2 = "698961.CGSMWGv6119V5_05987";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gardnerella_vaginalis_6119v5_node_name(this_library_node_name1));
/// assert!(is_valid_string_gardnerella_vaginalis_6119v5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gardnerella_vaginalis_6119v5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gardnerella_vaginalis_6119v5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["698961"]),
        None,
        Some("."),
        Some("CGSMWGv6119V5_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium diphtheriae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "698964.CDPW8_0001";
/// let this_library_node_name2 = "698964.CDPW8_2361";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_diphtheriae_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_diphtheriae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_diphtheriae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_diphtheriae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["698964"]),
        None,
        Some("."),
        Some("CDPW8_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Megasphaera genomosp. nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "699218.HMPREF0889_0001";
/// let this_library_node_name2 = "699218.HMPREF0889_1691";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_megasphaera_genomosp_node_name(this_library_node_name1));
/// assert!(is_valid_string_megasphaera_genomosp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_megasphaera_genomosp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_megasphaera_genomosp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["699218"]),
        None,
        Some("."),
        Some("HMPREF0889_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales genomosp. nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "699246.HMPREF0868_0002";
/// let this_library_node_name2 = "699246.HMPREF0868_1653";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_genomosp_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_genomosp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_genomosp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_genomosp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["699246"]),
        None,
        Some("."),
        Some("HMPREF0868_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus ratti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "699248.SRA_00013";
/// let this_library_node_name2 = "699248.SRA_10308";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_ratti_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_ratti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_ratti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_ratti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["699248"]),
        None,
        Some("."),
        Some("SRA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coriobacterium glomerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "700015.Corgl_0001";
/// let this_library_node_name2 = "700015.Corgl_R0006";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coriobacterium_glomerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_coriobacterium_glomerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coriobacterium_glomerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coriobacterium_glomerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["700015"]),
        None,
        Some("."),
        Some("Corgl_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium neoaurum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "700508.D174_00005";
/// let this_library_node_name2 = "700508.D174_27135";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_neoaurum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_neoaurum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_neoaurum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_neoaurum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["700508"]),
        None,
        Some("."),
        Some("D174_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Niastella koreensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "700598.Niako_0001";
/// let this_library_node_name2 = "700598.Niako_7366";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_niastella_koreensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_niastella_koreensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_niastella_koreensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_niastella_koreensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["700598"]),
        None,
        Some("."),
        Some("Niako_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio sp. N418 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "701176.VIBRN418_00005";
/// let this_library_node_name2 = "701176.VIBRN418_20344";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_sp_n418_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_sp_n418_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_sp_n418_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_sp_n418_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["701176"]),
        None,
        Some("."),
        Some("VIBRN418_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacter lignolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "701347.Entcl_0001";
/// let this_library_node_name2 = "701347.Entcl_4449";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacter_lignolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacter_lignolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacter_lignolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacter_lignolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["701347"]),
        None,
        Some("."),
        Some("Entcl_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pediococcus claussenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "701521.PECL_1";
/// let this_library_node_name2 = "701521.PECL_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pediococcus_claussenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pediococcus_claussenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pediococcus_claussenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pediococcus_claussenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["701521"]),
        None,
        Some("."),
        Some("PECL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novosphingobium sp. PP1Y nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "702113.PP1Y_AT10017";
/// let this_library_node_name2 = "702113.PP1Y_Mpl9992";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novosphingobium_sp_pp1y_node_name(this_library_node_name1));
/// assert!(is_valid_string_novosphingobium_sp_pp1y_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novosphingobium_sp_pp1y_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novosphingobium_sp_pp1y_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["702113"]),
        None,
        Some("."),
        Some("PP1Y_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas noxia F0398 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "702437.HMPREF9432_00001";
/// let this_library_node_name2 = "702437.HMPREF9432_01987";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_noxia_f0398_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_noxia_f0398_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_noxia_f0398_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_noxia_f0398_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["702437"]),
        None,
        Some("."),
        Some("HMPREF9432_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella oulorum F0390 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "702438.HMPREF9431_00001";
/// let this_library_node_name2 = "702438.HMPREF9431_02488";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_oulorum_f0390_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_oulorum_f0390_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_oulorum_f0390_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_oulorum_f0390_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["702438"]),
        None,
        Some("."),
        Some("HMPREF9431_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Turicibacter sanguinis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "702450.CUW_0001";
/// let this_library_node_name2 = "702450.CUW_2895";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_turicibacter_sanguinis_node_name(this_library_node_name1));
/// assert!(is_valid_string_turicibacter_sanguinis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_turicibacter_sanguinis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_turicibacter_sanguinis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["702450"]),
        None,
        Some("."),
        Some("CUW_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium bifidum PRL2010 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "702459.BBPR_0001";
/// let this_library_node_name2 = "702459.BBPR_1843";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_bifidum_prl2010_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_bifidum_prl2010_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_bifidum_prl2010_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_bifidum_prl2010_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["702459"]),
        None,
        Some("."),
        Some("BBPR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea ananatis LMG20103 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "706191.PANA_0001";
/// let this_library_node_name2 = "706191.PANA_4237";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_ananatis_lmg20103_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_ananatis_lmg20103_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_ananatis_lmg20103_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_ananatis_lmg20103_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["706191"]),
        None,
        Some("."),
        Some("PANA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solobacterium moorei F0204 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "706433.HMPREF9430_00001";
/// let this_library_node_name2 = "706433.HMPREF9430_02081";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solobacterium_moorei_f0204_node_name(this_library_node_name1));
/// assert!(is_valid_string_solobacterium_moorei_f0204_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solobacterium_moorei_f0204_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solobacterium_moorei_f0204_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["706433"]),
        None,
        Some("."),
        Some("HMPREF9430_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Megasphaera micronuciformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "706434.HMPREF9429_00001";
/// let this_library_node_name2 = "706434.HMPREF9429_01828";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_megasphaera_micronuciformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_megasphaera_micronuciformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_megasphaera_micronuciformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_megasphaera_micronuciformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["706434"]),
        None,
        Some("."),
        Some("HMPREF9429_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga sp. F0087 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "706436.HMPREF9074_07000";
/// let this_library_node_name2 = "706436.HMPREF9074_09561";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_sp_f0087_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_sp_f0087_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_sp_f0087_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_sp_f0087_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["706436"]),
        None,
        Some("."),
        Some("HMPREF9074_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus anginosus F0211 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "706437.HMPREF0813_00001";
/// let this_library_node_name2 = "706437.HMPREF0813_02076";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_anginosus_f0211_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_anginosus_f0211_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_anginosus_f0211_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_anginosus_f0211_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["706437"]),
        None,
        Some("."),
        Some("HMPREF0813_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. F0337 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "706439.HMPREF9057_00001";
/// let this_library_node_name2 = "706439.HMPREF9057_03203";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_f0337_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_f0337_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_f0337_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_f0337_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["706439"]),
        None,
        Some("."),
        Some("HMPREF9057_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfomonile tiedjei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "706587.Desti_0001";
/// let this_library_node_name2 = "706587.Desti_5641";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfomonile_tiedjei_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfomonile_tiedjei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfomonile_tiedjei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfomonile_tiedjei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["706587"]),
        None,
        Some("."),
        Some("Desti_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma gallisepticum F nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "708616.MGF_0005";
/// let this_library_node_name2 = "708616.MGF_5712";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_gallisepticum_f_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_gallisepticum_f_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_gallisepticum_f_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_gallisepticum_f_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["708616"]),
        None,
        Some("."),
        Some("MGF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfuricurvum kujiense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "709032.Sulku_0001";
/// let this_library_node_name2 = "709032.Sulku_R0042";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfuricurvum_kujiense_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfuricurvum_kujiense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfuricurvum_kujiense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfuricurvum_kujiense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["709032"]),
        None,
        Some("."),
        Some("Sulku_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobiaceae bacterium SG6C nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "709797.CSIRO_0001";
/// let this_library_node_name2 = "709797.CSIRO_4293";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobiaceae_bacterium_sg6c_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobiaceae_bacterium_sg6c_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobiaceae_bacterium_sg6c_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobiaceae_bacterium_sg6c_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["709797"]),
        None,
        Some("."),
        Some("CSIRO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus maricopensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "709986.Deima_0001";
/// let this_library_node_name2 = "709986.Deima_3301";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_maricopensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_maricopensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_maricopensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_maricopensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["709986"]),
        None,
        Some("."),
        Some("Deima_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Odoribacter splanchnicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "709991.Odosp_0001";
/// let this_library_node_name2 = "709991.Odosp_R0002";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_odoribacter_splanchnicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_odoribacter_splanchnicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_odoribacter_splanchnicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_odoribacter_splanchnicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["709991"]),
        None,
        Some("."),
        Some("Odosp_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frankia sp. QA3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "710111.FraQA3DRAFT_0001";
/// let this_library_node_name2 = "710111.FraQA3DRAFT_6547";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frankia_sp_qa3_node_name(this_library_node_name1));
/// assert!(is_valid_string_frankia_sp_qa3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frankia_sp_qa3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frankia_sp_qa3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["710111"]),
        None,
        Some("."),
        Some("FraQA3DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Colletotrichum fioriniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "710243.XP_007589695.1";
/// let this_library_node_name2 = "710243.XP_007603453.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_colletotrichum_fioriniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_colletotrichum_fioriniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_colletotrichum_fioriniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_colletotrichum_fioriniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["710243"]),
        None,
        Some("."),
        Some("XP_007"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter suis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "710393.HSUHS1_0001";
/// let this_library_node_name2 = "710393.HSUHS1_1222";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_suis_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_suis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_suis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_suis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["710393"]),
        None,
        Some("."),
        Some("HSUHS1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium chubuense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "710421.Mycch_0001";
/// let this_library_node_name2 = "710421.Mycch_5328";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_chubuense_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_chubuense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_chubuense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_chubuense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["710421"]),
        None,
        Some("."),
        Some("Mycch_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium rhodesiae NBB3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "710685.MycrhN_0001";
/// let this_library_node_name2 = "710685.MycrhN_6343";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_rhodesiae_nbb3_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_rhodesiae_nbb3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_rhodesiae_nbb3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_rhodesiae_nbb3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["710685"]),
        None,
        Some("."),
        Some("MycrhN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium smegmatis JS623 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "710686.Mycsm_00001";
/// let this_library_node_name2 = "710686.Mycsm_06513";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_smegmatis_js623_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_smegmatis_js623_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_smegmatis_js623_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_smegmatis_js623_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["710686"]),
        None,
        Some("."),
        Some("Mycsm_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium tusciae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "710687.KI912270_gene1";
/// let this_library_node_name2 = "710687.KI912270_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_tusciae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_tusciae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_tusciae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_tusciae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["710687"]),
        None,
        Some("."),
        Some("KI912270_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Intrasporangium calvum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "710696.Intca_0001";
/// let this_library_node_name2 = "710696.Intca_R0022";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_intrasporangium_calvum_node_name(this_library_node_name1));
/// assert!(is_valid_string_intrasporangium_calvum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_intrasporangium_calvum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_intrasporangium_calvum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["710696"]),
        None,
        Some("."),
        Some("Intca_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. GXT6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "711393.AYRX01000001_gene4306";
/// let this_library_node_name2 = "711393.AYRX01000151_gene5600";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_gxt6_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_gxt6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_gxt6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_gxt6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["711393"]),
        None,
        Some("."),
        Some("AYRX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea vagans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "712898.Pvag_0001";
/// let this_library_node_name2 = "712898.Pvag_pPag10162";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_vagans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_vagans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_vagans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_vagans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["712898"]),
        None,
        Some("."),
        Some("Pvag_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio thiocyanodenitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "713586.KB900536_gene100";
/// let this_library_node_name2 = "713586.KB900538_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_thiocyanodenitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_thiocyanodenitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_thiocyanodenitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_thiocyanodenitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["713586"]),
        None,
        Some("."),
        Some("KB90053"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio thiocyanoxidans ARh4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "713587.THITH_00005";
/// let this_library_node_name2 = "713587.THITH_17510";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_thiocyanoxidans_arh4_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_thiocyanoxidans_arh4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_thiocyanoxidans_arh4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_thiocyanoxidans_arh4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["713587"]),
        None,
        Some("."),
        Some("THITH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus iners nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "713605.ADHG01000001_gene1";
/// let this_library_node_name2 = "713605.ADHG01000007_gene760";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_iners_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_iners_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_iners_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_iners_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["713605"]),
        None,
        Some("."),
        Some("ADHG0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leucobacter chromiiresistens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "714083.JH370377_gene10";
/// let this_library_node_name2 = "714083.JH370405_gene2797";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leucobacter_chromiiresistens_node_name(this_library_node_name1));
/// assert!(is_valid_string_leucobacter_chromiiresistens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leucobacter_chromiiresistens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leucobacter_chromiiresistens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["714083"]),
        None,
        Some("."),
        Some("JH370"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus sanfranciscensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "714313.LSA_00010";
/// let this_library_node_name2 = "714313.LSA_2p00630";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_sanfranciscensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_sanfranciscensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_sanfranciscensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_sanfranciscensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["714313"]),
        None,
        Some("."),
        Some("LSA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mucilaginibacter paludis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "714943.Mucpa_0001";
/// let this_library_node_name2 = "714943.Mucpa_R0012";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mucilaginibacter_paludis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mucilaginibacter_paludis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mucilaginibacter_paludis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mucilaginibacter_paludis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["714943"]),
        None,
        Some("."),
        Some("Mucpa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysinibacillus fusiformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "714961.BFZC1_00005";
/// let this_library_node_name2 = "714961.BFZC1_24230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysinibacillus_fusiformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysinibacillus_fusiformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysinibacillus_fusiformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysinibacillus_fusiformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["714961"]),
        None,
        Some("."),
        Some("BFZC1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Asticcacaulis biprosthecum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "715226.ABI_00010";
/// let this_library_node_name2 = "715226.ABI_47670";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_asticcacaulis_biprosthecum_node_name(this_library_node_name1));
/// assert!(is_valid_string_asticcacaulis_biprosthecum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_asticcacaulis_biprosthecum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_asticcacaulis_biprosthecum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["715226"]),
        None,
        Some("."),
        Some("ABI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alteromonas sp. SN2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "715451.ambt_00005";
/// let this_library_node_name2 = "715451.ambt_22245";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alteromonas_sp_sn2_node_name(this_library_node_name1));
/// assert!(is_valid_string_alteromonas_sp_sn2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alteromonas_sp_sn2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alteromonas_sp_sn2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["715451"]),
        None,
        Some("."),
        Some("ambt_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacter cloacae ATCC13047 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "716541.ECL_00001";
/// let this_library_node_name2 = "716541.ECL_A277";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacter_cloacae_atcc13047_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacter_cloacae_atcc13047_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacter_cloacae_atcc13047_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacter_cloacae_atcc13047_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["716541"]),
        None,
        Some("."),
        Some("ECL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Waddlia chondrophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "716544.wcw_0001";
/// let this_library_node_name2 = "716544.wcw_p0022";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_waddlia_chondrophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_waddlia_chondrophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_waddlia_chondrophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_waddlia_chondrophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["716544"]),
        None,
        Some("."),
        Some("wcw_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ensifer sojae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "716928.AJQT01000001_gene196";
/// let this_library_node_name2 = "716928.AJQT01000231_gene3562";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ensifer_sojae_node_name(this_library_node_name1));
/// assert!(is_valid_string_ensifer_sojae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ensifer_sojae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ensifer_sojae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["716928"]),
        None,
        Some("."),
        Some("AJQT01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flexistipes sinusarabici nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "717231.Flexsi_0001";
/// let this_library_node_name2 = "717231.Flexsi_R0008";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flexistipes_sinusarabici_node_name(this_library_node_name1));
/// assert!(is_valid_string_flexistipes_sinusarabici_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flexistipes_sinusarabici_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flexistipes_sinusarabici_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["717231"]),
        None,
        Some("."),
        Some("Flexsi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermobacillus composti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "717605.Theco_0001";
/// let this_library_node_name2 = "717605.Theco_4121";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermobacillus_composti_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermobacillus_composti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermobacillus_composti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermobacillus_composti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["717605"]),
        None,
        Some("."),
        Some("Theco_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus curdlanolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "717606.PaecuDRAFT_0001";
/// let this_library_node_name2 = "717606.PaecuDRAFT_4847";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_curdlanolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_curdlanolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_curdlanolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_curdlanolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["717606"]),
        None,
        Some("."),
        Some("PaecuDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalimicrobium aerophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "717772.THIAE_00005";
/// let this_library_node_name2 = "717772.THIAE_10650";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalimicrobium_aerophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalimicrobium_aerophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalimicrobium_aerophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalimicrobium_aerophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["717772"]),
        None,
        Some("."),
        Some("THIAE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalimicrobium cyclicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "717773.Thicy_0001";
/// let this_library_node_name2 = "717773.Thicy_1684";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalimicrobium_cyclicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalimicrobium_cyclicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalimicrobium_cyclicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalimicrobium_cyclicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["717773"]),
        None,
        Some("."),
        Some("Thicy_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinomonas mediterranea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "717774.Marme_0001";
/// let this_library_node_name2 = "717774.Marme_4228";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinomonas_mediterranea_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinomonas_mediterranea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinomonas_mediterranea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinomonas_mediterranea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["717774"]),
        None,
        Some("."),
        Some("Marme_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomicrobium sp. MC1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "717785.HYPMC_0001";
/// let this_library_node_name2 = "717785.HYPMC_4953";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomicrobium_sp_mc1_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomicrobium_sp_mc1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomicrobium_sp_mc1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomicrobium_sp_mc1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["717785"]),
        None,
        Some("."),
        Some("HYPMC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Faecalibacterium prausnitzii L26 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "718252.FP2_00100";
/// let this_library_node_name2 = "718252.FP2_32570";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_faecalibacterium_prausnitzii_l26_node_name(this_library_node_name1));
/// assert!(is_valid_string_faecalibacterium_prausnitzii_l26_node_name(this_library_node_name2));
/// assert!(!is_valid_string_faecalibacterium_prausnitzii_l26_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_faecalibacterium_prausnitzii_l26_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["718252"]),
        None,
        Some("."),
        Some("FP2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium clariflavum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "720554.Clocl_0001";
/// let this_library_node_name2 = "720554.Clocl_4230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_clariflavum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_clariflavum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_clariflavum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_clariflavum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["720554"]),
        None,
        Some("."),
        Some("Clocl_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus atrophaeus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "720555.BATR1942_00010";
/// let this_library_node_name2 = "720555.BATR1942_21160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_atrophaeus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_atrophaeus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_atrophaeus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_atrophaeus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["720555"]),
        None,
        Some("."),
        Some("BATR1942_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas haloplanktis ANT505 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "722419.PH505_aa00010";
/// let this_library_node_name2 = "722419.PH505_fk00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_haloplanktis_ant505_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_haloplanktis_ant505_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_haloplanktis_ant505_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_haloplanktis_ant505_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["722419"]),
        None,
        Some("."),
        Some("PH505_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma pneumoniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "722438.MPNE_0001";
/// let this_library_node_name2 = "722438.MPNE_0800";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_pneumoniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_pneumoniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_pneumoniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_pneumoniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["722438"]),
        None,
        Some("."),
        Some("MPNE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Idiomarina xiamenensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "740709.A10D4_00005";
/// let this_library_node_name2 = "740709.A10D4_13627";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_idiomarina_xiamenensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_idiomarina_xiamenensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_idiomarina_xiamenensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_idiomarina_xiamenensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["740709"]),
        None,
        Some("."),
        Some("A10D4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rahnella sp. Y9602 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "741091.Rahaq_0001";
/// let this_library_node_name2 = "741091.Rahaq_5045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rahnella_sp_y9602_node_name(this_library_node_name1));
/// assert!(is_valid_string_rahnella_sp_y9602_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rahnella_sp_y9602_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rahnella_sp_y9602_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["741091"]),
        None,
        Some("."),
        Some("Rahaq_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Achromobacter piechaudii ATCC43553 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742159.HMPREF0004_0001";
/// let this_library_node_name2 = "742159.HMPREF0004_5755";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_achromobacter_piechaudii_atcc43553_node_name(this_library_node_name1));
/// assert!(is_valid_string_achromobacter_piechaudii_atcc43553_node_name(this_library_node_name2));
/// assert!(!is_valid_string_achromobacter_piechaudii_atcc43553_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_achromobacter_piechaudii_atcc43553_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742159"]),
        None,
        Some("."),
        Some("HMPREF0004_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Collinsella sp. 4847FAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742722.HMPREF9463_00001";
/// let this_library_node_name2 = "742722.HMPREF9463_02042";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_collinsella_sp_4847faa_node_name(this_library_node_name1));
/// assert!(is_valid_string_collinsella_sp_4847faa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_collinsella_sp_4847faa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_collinsella_sp_4847faa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742722"]),
        None,
        Some("."),
        Some("HMPREF9463_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium 2146FAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742723.HMPREF9477_00001";
/// let this_library_node_name2 = "742723.HMPREF9477_02175";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_2146faa_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_2146faa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_2146faa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_2146faa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742723"]),
        None,
        Some("."),
        Some("HMPREF9477_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alistipes indistinctus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742725.HMPREF9450_00001";
/// let this_library_node_name2 = "742725.HMPREF9450_02348";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alistipes_indistinctus_node_name(this_library_node_name1));
/// assert!(is_valid_string_alistipes_indistinctus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alistipes_indistinctus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alistipes_indistinctus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742725"]),
        None,
        Some("."),
        Some("HMPREF9450_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Barnesiella intestinihominis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742726.HMPREF9448_00001";
/// let this_library_node_name2 = "742726.HMPREF9448_02880";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_barnesiella_intestinihominis_node_name(this_library_node_name1));
/// assert!(is_valid_string_barnesiella_intestinihominis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_barnesiella_intestinihominis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_barnesiella_intestinihominis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742726"]),
        None,
        Some("."),
        Some("HMPREF9448_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides oleiciplenus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742727.HMPREF9447_00001";
/// let this_library_node_name2 = "742727.HMPREF9447_05530";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_oleiciplenus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_oleiciplenus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_oleiciplenus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_oleiciplenus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742727"]),
        None,
        Some("."),
        Some("HMPREF9447_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium citroniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742733.HMPREF9469_00001";
/// let this_library_node_name2 = "742733.HMPREF9469_06079";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_citroniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_citroniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_citroniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_citroniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742733"]),
        None,
        Some("."),
        Some("HMPREF9469_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium clostridioforme nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742735.HMPREF9467_00001";
/// let this_library_node_name2 = "742735.HMPREF9467_05256";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_clostridioforme_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_clostridioforme_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_clostridioforme_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_clostridioforme_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742735"]),
        None,
        Some("."),
        Some("HMPREF9467_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium orbiscindens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742738.HMPREF9460_00001";
/// let this_library_node_name2 = "742738.HMPREF9460_04335";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_orbiscindens_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_orbiscindens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_orbiscindens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_orbiscindens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742738"]),
        None,
        Some("."),
        Some("HMPREF9460_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium symbiosum WAL14163 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742740.HMPREF9474_00001";
/// let this_library_node_name2 = "742740.HMPREF9474_04691";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_symbiosum_wal14163_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_symbiosum_wal14163_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_symbiosum_wal14163_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_symbiosum_wal14163_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742740"]),
        None,
        Some("."),
        Some("HMPREF9474_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium symbiosum WAL14673 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742741.HMPREF9475_00001";
/// let this_library_node_name2 = "742741.HMPREF9475_04198";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_symbiosum_wal14673_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_symbiosum_wal14673_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_symbiosum_wal14673_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_symbiosum_wal14673_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742741"]),
        None,
        Some("."),
        Some("HMPREF9475_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Collinsella tanakaei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742742.HMPREF9452_00001";
/// let this_library_node_name2 = "742742.HMPREF9452_02212";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_collinsella_tanakaei_node_name(this_library_node_name1));
/// assert!(is_valid_string_collinsella_tanakaei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_collinsella_tanakaei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_collinsella_tanakaei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742742"]),
        None,
        Some("."),
        Some("HMPREF9452_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dialister succinatiphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742743.HMPREF9453_00001";
/// let this_library_node_name2 = "742743.HMPREF9453_02155";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dialister_succinatiphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_dialister_succinatiphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dialister_succinatiphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dialister_succinatiphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742743"]),
        None,
        Some("."),
        Some("HMPREF9453_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dorea formicigenerans 4653AFAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742765.HMPREF9457_00001";
/// let this_library_node_name2 = "742765.HMPREF9457_03840";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dorea_formicigenerans_4653afaa_node_name(this_library_node_name1));
/// assert!(is_valid_string_dorea_formicigenerans_4653afaa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dorea_formicigenerans_4653afaa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dorea_formicigenerans_4653afaa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742765"]),
        None,
        Some("."),
        Some("HMPREF9457_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dysgonomonas gadei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742766.HMPREF9455_00001";
/// let this_library_node_name2 = "742766.HMPREF9455_04156";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dysgonomonas_gadei_node_name(this_library_node_name1));
/// assert!(is_valid_string_dysgonomonas_gadei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dysgonomonas_gadei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dysgonomonas_gadei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742766"]),
        None,
        Some("."),
        Some("HMPREF9455_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dysgonomonas mossii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742767.HMPREF9456_00001";
/// let this_library_node_name2 = "742767.HMPREF9456_03429";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dysgonomonas_mossii_node_name(this_library_node_name1));
/// assert!(is_valid_string_dysgonomonas_mossii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dysgonomonas_mossii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dysgonomonas_mossii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742767"]),
        None,
        Some("."),
        Some("HMPREF9456_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Odoribacter laneus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742817.HMPREF9449_00001";
/// let this_library_node_name2 = "742817.HMPREF9449_03103";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_odoribacter_laneus_node_name(this_library_node_name1));
/// assert!(is_valid_string_odoribacter_laneus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_odoribacter_laneus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_odoribacter_laneus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742817"]),
        None,
        Some("."),
        Some("HMPREF9449_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Slackia piriformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742818.HMPREF9451_00004";
/// let this_library_node_name2 = "742818.HMPREF9451_01863";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_slackia_piriformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_slackia_piriformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_slackia_piriformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_slackia_piriformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742818"]),
        None,
        Some("."),
        Some("HMPREF9451_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sutterella wadsworthensis 3145B nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742821.HMPREF9464_00001";
/// let this_library_node_name2 = "742821.HMPREF9464_02373";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sutterella_wadsworthensis_3145b_node_name(this_library_node_name1));
/// assert!(is_valid_string_sutterella_wadsworthensis_3145b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sutterella_wadsworthensis_3145b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sutterella_wadsworthensis_3145b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742821"]),
        None,
        Some("."),
        Some("HMPREF9464_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sutterella wadsworthensis 2159BFAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "742823.HMPREF9465_00001";
/// let this_library_node_name2 = "742823.HMPREF9465_02369";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sutterella_wadsworthensis_2159bfaa_node_name(this_library_node_name1));
/// assert!(is_valid_string_sutterella_wadsworthensis_2159bfaa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sutterella_wadsworthensis_2159bfaa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sutterella_wadsworthensis_2159bfaa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["742823"]),
        None,
        Some("."),
        Some("HMPREF9465_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidithiobacillus ferrivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743299.Acife_0001";
/// let this_library_node_name2 = "743299.Acife_3280";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidithiobacillus_ferrivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidithiobacillus_ferrivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidithiobacillus_ferrivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidithiobacillus_ferrivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743299"]),
        None,
        Some("."),
        Some("Acife_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus scotoductus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743525.TSC_c00010";
/// let this_library_node_name2 = "743525.TSC_p800120";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_scotoductus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_scotoductus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_scotoductus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_scotoductus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743525"]),
        None,
        Some("."),
        Some("TSC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Isoptericola variabilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743718.Isova_0001";
/// let this_library_node_name2 = "743718.Isova_3021";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_isoptericola_variabilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_isoptericola_variabilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_isoptericola_variabilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_isoptericola_variabilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743718"]),
        None,
        Some("."),
        Some("Isova_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus lactis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743719.PaelaDRAFT_0001";
/// let this_library_node_name2 = "743719.PaelaDRAFT_6149";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_lactis_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_lactis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_lactis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_lactis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743719"]),
        None,
        Some("."),
        Some("PaelaDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas fulva nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743720.Psefu_0001";
/// let this_library_node_name2 = "743720.Psefu_4496";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_fulva_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_fulva_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_fulva_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_fulva_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743720"]),
        None,
        Some("."),
        Some("Psefu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoxanthomonas suwonensis 111 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743721.Psesu_0001";
/// let this_library_node_name2 = "743721.Psesu_3111";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoxanthomonas_suwonensis_111_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoxanthomonas_suwonensis_111_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoxanthomonas_suwonensis_111_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoxanthomonas_suwonensis_111_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743721"]),
        None,
        Some("."),
        Some("Psesu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobacterium sp. 21 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743722.Sph21_0001";
/// let this_library_node_name2 = "743722.Sph21_5273";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobacterium_sp_21_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobacterium_sp_21_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobacterium_sp_21_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobacterium_sp_21_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743722"]),
        None,
        Some("."),
        Some("Sph21_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylocystis sp. SB2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743836.AYNA01000001_gene1313";
/// let this_library_node_name2 = "743836.AYNA01000149_gene639";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylocystis_sp_sb2_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylocystis_sp_sb2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylocystis_sp_sb2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylocystis_sp_sb2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743836"]),
        None,
        Some("."),
        Some("AYNA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma putrefaciens KS1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743965.MPUT_0001";
/// let this_library_node_name2 = "743965.MPUT_0725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_putrefaciens_ks1_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_putrefaciens_ks1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_putrefaciens_ks1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_putrefaciens_ks1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743965"]),
        None,
        Some("."),
        Some("MPUT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma bovoculi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743966.MYB_00005";
/// let this_library_node_name2 = "743966.MYB_02985";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_bovoculi_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_bovoculi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_bovoculi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_bovoculi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743966"]),
        None,
        Some("."),
        Some("MYB_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moraxella bovoculi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "743974.MBO_00005";
/// let this_library_node_name2 = "743974.MBO_09932";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moraxella_bovoculi_node_name(this_library_node_name1));
/// assert!(is_valid_string_moraxella_bovoculi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moraxella_bovoculi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moraxella_bovoculi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["743974"]),
        None,
        Some("."),
        Some("MBO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema caldaria nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "744872.Spica_0001";
/// let this_library_node_name2 = "744872.Spica_R0030";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_caldaria_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_caldaria_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_caldaria_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_caldaria_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["744872"]),
        None,
        Some("."),
        Some("Spica_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ahrensia sp. R2A130 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "744979.R2A130_0001";
/// let this_library_node_name2 = "744979.R2A130_3687";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ahrensia_sp_r2a130_node_name(this_library_node_name1));
/// assert!(is_valid_string_ahrensia_sp_r2a130_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ahrensia_sp_r2a130_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ahrensia_sp_r2a130_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["744979"]),
        None,
        Some("."),
        Some("R2A130_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseibium sp. TrichSKD4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "744980.TRICHSKD4_0001";
/// let this_library_node_name2 = "744980.TRICHSKD4_6305";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseibium_sp_trichskd4_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseibium_sp_trichskd4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseibium_sp_trichskd4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseibium_sp_trichskd4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["744980"]),
        None,
        Some("."),
        Some("TRICHSKD4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING alpha proteobacterium HIMB59 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "744985.HIMB59_00000010";
/// let this_library_node_name2 = "744985.HIMB59_00015320";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alpha_proteobacterium_himb59_node_name(this_library_node_name1));
/// assert!(is_valid_string_alpha_proteobacterium_himb59_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alpha_proteobacterium_himb59_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alpha_proteobacterium_himb59_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["744985"]),
        None,
        Some("."),
        Some("HIMB59_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium HIMB55 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "745014.OMB55_00000020";
/// let this_library_node_name2 = "745014.OMB55_00025150";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_himb55_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_himb55_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_himb55_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_himb55_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["745014"]),
        None,
        Some("."),
        Some("OMB55_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rahnella aquatilis CIP78.65 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "745277.GRAQ_00003";
/// let this_library_node_name2 = "745277.GRAQ_05018";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rahnella_aquatilis_cip7865_node_name(this_library_node_name1));
/// assert!(is_valid_string_rahnella_aquatilis_cip7865_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rahnella_aquatilis_cip7865_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rahnella_aquatilis_cip7865_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["745277"]),
        None,
        Some("."),
        Some("GRAQ_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. MM1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "745310.G432_00005";
/// let this_library_node_name2 = "745310.G432_21636";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_mm1_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_mm1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_mm1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_mm1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["745310"]),
        None,
        Some("."),
        Some("G432_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gallaecimonas xiamenensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "745411.B3C1_00005";
/// let this_library_node_name2 = "745411.B3C1_19163";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gallaecimonas_xiamenensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gallaecimonas_xiamenensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gallaecimonas_xiamenensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gallaecimonas_xiamenensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["745411"]),
        None,
        Some("."),
        Some("B3C1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Olleya sp. VCSM12 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "745718.JADT01000001_gene1543";
/// let this_library_node_name2 = "745718.JADT01000054_gene241";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_olleya_sp_vcsm12_node_name(this_library_node_name1));
/// assert!(is_valid_string_olleya_sp_vcsm12_node_name(this_library_node_name2));
/// assert!(!is_valid_string_olleya_sp_vcsm12_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_olleya_sp_vcsm12_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["745718"]),
        None,
        Some("."),
        Some("JADT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus gobiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "745776.DGo_CA0001";
/// let this_library_node_name2 = "745776.DGo_PC0282";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_gobiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_gobiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_gobiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_gobiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["745776"]),
        None,
        Some("."),
        Some("DGo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aspergillus fumigatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "746128.CADAFUBP00000001";
/// let this_library_node_name2 = "746128.CADAFUBP00009929";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aspergillus_fumigatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_aspergillus_fumigatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aspergillus_fumigatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aspergillus_fumigatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["746128"]),
        None,
        Some("."),
        Some("CADAFUBP0000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aequorivita sublithincola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "746697.Aeqsu_0001";
/// let this_library_node_name2 = "746697.Aeqsu_3244";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aequorivita_sublithincola_node_name(this_library_node_name1));
/// assert!(is_valid_string_aequorivita_sublithincola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aequorivita_sublithincola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aequorivita_sublithincola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["746697"]),
        None,
        Some("."),
        Some("Aeqsu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermodesulfobium narugense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "747365.Thena_0001";
/// let this_library_node_name2 = "747365.Thena_R0046";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermodesulfobium_narugense_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermodesulfobium_narugense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermodesulfobium_narugense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermodesulfobium_narugense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["747365"]),
        None,
        Some("."),
        Some("Thena_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma alligatoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "747682.MALL_0001";
/// let this_library_node_name2 = "747682.MALL_0849";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_alligatoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_alligatoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_alligatoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_alligatoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["747682"]),
        None,
        Some("."),
        Some("MALL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Faecalibacterium prausnitzii KLE1255 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "748224.HMPREF9436_00001";
/// let this_library_node_name2 = "748224.HMPREF9436_03412";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_faecalibacterium_prausnitzii_kle1255_node_name(this_library_node_name1));
/// assert!(is_valid_string_faecalibacterium_prausnitzii_kle1255_node_name(this_library_node_name2));
/// assert!(!is_valid_string_faecalibacterium_prausnitzii_kle1255_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_faecalibacterium_prausnitzii_kle1255_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["748224"]),
        None,
        Some("."),
        Some("HMPREF9436_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Azoarcus sp. KH32C nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "748247.AZKH_0001";
/// let this_library_node_name2 = "748247.AZKH_p0657";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_azoarcus_sp_kh32c_node_name(this_library_node_name1));
/// assert!(is_valid_string_azoarcus_sp_kh32c_node_name(this_library_node_name2));
/// assert!(!is_valid_string_azoarcus_sp_kh32c_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_azoarcus_sp_kh32c_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["748247"]),
        None,
        Some("."),
        Some("AZKH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudogulbenkiania sp. NH8B nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "748280.NH8B_0001";
/// let this_library_node_name2 = "748280.NH8B_4127";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudogulbenkiania_sp_nh8b_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudogulbenkiania_sp_nh8b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudogulbenkiania_sp_nh8b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudogulbenkiania_sp_nh8b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["748280"]),
        None,
        Some("."),
        Some("NH8B_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halobacteroides halobius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "748449.Halha_0001";
/// let this_library_node_name2 = "748449.Halha_2634";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halobacteroides_halobius_node_name(this_library_node_name1));
/// assert!(is_valid_string_halobacteroides_halobius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halobacteroides_halobius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halobacteroides_halobius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["748449"]),
        None,
        Some("."),
        Some("Halha_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALSr1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "748658.KB907312_gene1091";
/// let this_library_node_name2 = "748658.KB907336_gene623";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_alsr1_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_alsr1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_alsr1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_alsr1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["748658"]),
        None,
        Some("."),
        Some("KB9073"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus crispatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "748671.LCRIS_00001";
/// let this_library_node_name2 = "748671.LCRIS_02024";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_crispatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_crispatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_crispatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_crispatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["748671"]),
        None,
        Some("."),
        Some("LCRIS_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium ljungdahlii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "748727.CLJU_c00010";
/// let this_library_node_name2 = "748727.CLJU_c42970";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_ljungdahlii_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_ljungdahlii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_ljungdahlii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_ljungdahlii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["748727"]),
        None,
        Some("."),
        Some("CLJU_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitratifractor salsuginis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "749222.Nitsa_0001";
/// let this_library_node_name2 = "749222.Nitsa_R0015";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitratifractor_salsuginis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitratifractor_salsuginis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitratifractor_salsuginis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitratifractor_salsuginis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["749222"]),
        None,
        Some("."),
        Some("Nitsa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces bingchenggensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "749414.SBI_00001";
/// let this_library_node_name2 = "749414.SBI_10025";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_bingchenggensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_bingchenggensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_bingchenggensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_bingchenggensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["749414"]),
        None,
        Some("."),
        Some("SBI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolatopsis mediterranei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "749927.AMED_0001";
/// let this_library_node_name2 = "749927.AMED_9366";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolatopsis_mediterranei_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolatopsis_mediterranei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolatopsis_mediterranei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolatopsis_mediterranei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["749927"]),
        None,
        Some("."),
        Some("AMED_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halobacterium sp. DL1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "751944.HALDL1_00005";
/// let this_library_node_name2 = "751944.HALDL1_16835";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halobacterium_sp_dl1_node_name(this_library_node_name1));
/// assert!(is_valid_string_halobacterium_sp_dl1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halobacterium_sp_dl1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halobacterium_sp_dl1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["751944"]),
        None,
        Some("."),
        Some("HALDL1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus oshimai nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "751945.Theos_0001";
/// let this_library_node_name2 = "751945.Theos_2206";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_oshimai_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_oshimai_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_oshimai_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_oshimai_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["751945"]),
        None,
        Some("."),
        Some("Theos_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium HIMB30 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "751994.AGIG01000001_gene925";
/// let this_library_node_name2 = "751994.AGIG01000036_gene2199";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_himb30_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_himb30_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_himb30_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_himb30_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["751994"]),
        None,
        Some("."),
        Some("AGIG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema phagedenis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "754027.HMPREF9554_00001";
/// let this_library_node_name2 = "754027.HMPREF9554_03197";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_phagedenis_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_phagedenis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_phagedenis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_phagedenis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["754027"]),
        None,
        Some("."),
        Some("HMPREF9554_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium australicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "754035.Mesau_00001";
/// let this_library_node_name2 = "754035.Mesau_06080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_australicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_australicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_australicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_australicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["754035"]),
        None,
        Some("."),
        Some("Mesau_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium freudenreichii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "754252.PFREUD_00010";
/// let this_library_node_name2 = "754252.PFREUD_25170";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_freudenreichii_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_freudenreichii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_freudenreichii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_freudenreichii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["754252"]),
        None,
        Some("."),
        Some("PFREUD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia sp. TW09308 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "754331.AEME01000001_gene1";
/// let this_library_node_name2 = "754331.AEME01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_sp_tw09308_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_sp_tw09308_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_sp_tw09308_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_sp_tw09308_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["754331"]),
        None,
        Some("."),
        Some("AEME01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photobacterium aphoticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "754436.JCM19237_1";
/// let this_library_node_name2 = "754436.JCM19237_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photobacterium_aphoticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_photobacterium_aphoticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photobacterium_aphoticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photobacterium_aphoticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["754436"]),
        None,
        Some("."),
        Some("JCM19237_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylophaga nitratireducenticrescens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "754476.Q7A_10";
/// let this_library_node_name2 = "754476.Q7A_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylophaga_nitratireducenticrescens_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylophaga_nitratireducenticrescens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylophaga_nitratireducenticrescens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylophaga_nitratireducenticrescens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["754476"]),
        None,
        Some("."),
        Some("Q7A_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylophaga frappieri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "754477.Q7C_1";
/// let this_library_node_name2 = "754477.Q7C_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylophaga_frappieri_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylophaga_frappieri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylophaga_frappieri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylophaga_frappieri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["754477"]),
        None,
        Some("."),
        Some("Q7C_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanobacterium aponinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "755178.Cyan10605_0001";
/// let this_library_node_name2 = "755178.Cyan10605_3559";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanobacterium_aponinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanobacterium_aponinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanobacterium_aponinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanobacterium_aponinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["755178"]),
        None,
        Some("."),
        Some("Cyan10605_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. BNL1100 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "755731.Clo1100_0001";
/// let this_library_node_name2 = "755731.Clo1100_4118";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_bnl1100_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_bnl1100_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_bnl1100_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_bnl1100_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["755731"]),
        None,
        Some("."),
        Some("Clo1100_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fluviicola taffensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "755732.Fluta_0001";
/// let this_library_node_name2 = "755732.Fluta_4082";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fluviicola_taffensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_fluviicola_taffensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fluviicola_taffensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fluviicola_taffensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["755732"]),
        None,
        Some("."),
        Some("Fluta_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microcoleus vaginatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "756067.MicvaDRAFT_0001";
/// let this_library_node_name2 = "756067.MicvaDRAFT_5576";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microcoleus_vaginatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_microcoleus_vaginatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microcoleus_vaginatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microcoleus_vaginatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["756067"]),
        None,
        Some("."),
        Some("MicvaDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Planctomyces brasiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "756272.Plabr_0001";
/// let this_library_node_name2 = "756272.Plabr_R0045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_planctomyces_brasiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_planctomyces_brasiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_planctomyces_brasiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_planctomyces_brasiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["756272"]),
        None,
        Some("."),
        Some("Plabr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfitobacterium dehalogenans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "756499.Desde_0001";
/// let this_library_node_name2 = "756499.Desde_4254";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfitobacterium_dehalogenans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfitobacterium_dehalogenans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfitobacterium_dehalogenans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfitobacterium_dehalogenans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["756499"]),
        None,
        Some("."),
        Some("Desde_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloferacales archaeon DL31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "756883.Halar_0032";
/// let this_library_node_name2 = "756883.Halar_3737";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloferacales_archaeon_dl31_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloferacales_archaeon_dl31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloferacales_archaeon_dl31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloferacales_archaeon_dl31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["756883"]),
        None,
        Some("."),
        Some("Halar_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Herbaspirillum seropedicae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "757424.Hsero_0001";
/// let this_library_node_name2 = "757424.Hsero_4804";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_herbaspirillum_seropedicae_node_name(this_library_node_name1));
/// assert!(is_valid_string_herbaspirillum_seropedicae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_herbaspirillum_seropedicae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_herbaspirillum_seropedicae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["757424"]),
        None,
        Some("."),
        Some("Hsero_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ketogulonicigenium vulgare nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "759362.KVU_0001";
/// let this_library_node_name2 = "759362.KVU_2596";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ketogulonicigenium_vulgare_node_name(this_library_node_name1));
/// assert!(is_valid_string_ketogulonicigenium_vulgare_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ketogulonicigenium_vulgare_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ketogulonicigenium_vulgare_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["759362"]),
        None,
        Some("."),
        Some("KVU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus dysgalactiae equisimilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "759913.SDSE_0001";
/// let this_library_node_name2 = "759913.SDSE_2287";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_dysgalactiae_equisimilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_dysgalactiae_equisimilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_dysgalactiae_equisimilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_dysgalactiae_equisimilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["759913"]),
        None,
        Some("."),
        Some("SDSE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachyspira pilosicoli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "759914.BP951000_0001";
/// let this_library_node_name2 = "759914.BP951000_2338";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachyspira_pilosicoli_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachyspira_pilosicoli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachyspira_pilosicoli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachyspira_pilosicoli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["759914"]),
        None,
        Some("."),
        Some("BP951000_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphaerochaeta coccoides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "760011.Spico_0001";
/// let this_library_node_name2 = "760011.Spico_R0016";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphaerochaeta_coccoides_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphaerochaeta_coccoides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphaerochaeta_coccoides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphaerochaeta_coccoides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["760011"]),
        None,
        Some("."),
        Some("Spico_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Massilia consociata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "760117.JN27_00010";
/// let this_library_node_name2 = "760117.JN27_23990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_massilia_consociata_node_name(this_library_node_name1));
/// assert!(is_valid_string_massilia_consociata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_massilia_consociata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_massilia_consociata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["760117"]),
        None,
        Some("."),
        Some("JN27_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hippea maritima nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "760142.Hipma_0001";
/// let this_library_node_name2 = "760142.Hipma_1723";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hippea_maritima_node_name(this_library_node_name1));
/// assert!(is_valid_string_hippea_maritima_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hippea_maritima_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hippea_maritima_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["760142"]),
        None,
        Some("."),
        Some("Hipma_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurospirillum barnesii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "760154.Sulba_0001";
/// let this_library_node_name2 = "760154.Sulba_2565";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurospirillum_barnesii_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurospirillum_barnesii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurospirillum_barnesii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurospirillum_barnesii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["760154"]),
        None,
        Some("."),
        Some("Sulba_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haliscomenobacter hydrossis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "760192.Halhy_0001";
/// let this_library_node_name2 = "760192.Halhy_R0059";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haliscomenobacter_hydrossis_node_name(this_library_node_name1));
/// assert!(is_valid_string_haliscomenobacter_hydrossis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haliscomenobacter_hydrossis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haliscomenobacter_hydrossis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["760192"]),
        None,
        Some("."),
        Some("Halhy_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum kuznetsovii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "760568.Desku_0001";
/// let this_library_node_name2 = "760568.Desku_3572";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_kuznetsovii_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_kuznetsovii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_kuznetsovii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_kuznetsovii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["760568"]),
        None,
        Some("."),
        Some("Desku_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Runella slithyformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "761193.Runsl_0001";
/// let this_library_node_name2 = "761193.Runsl_R0032";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_runella_slithyformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_runella_slithyformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_runella_slithyformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_runella_slithyformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["761193"]),
        None,
        Some("."),
        Some("Runsl_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leuconostoc kimchii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762051.LKI_00005";
/// let this_library_node_name2 = "762051.LKI_10801";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leuconostoc_kimchii_node_name(this_library_node_name1));
/// assert!(is_valid_string_leuconostoc_kimchii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leuconostoc_kimchii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leuconostoc_kimchii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762051"]),
        None,
        Some("."),
        Some("LKI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium stellenboschense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762211.BSTEL_0001";
/// let this_library_node_name2 = "762211.BSTEL_3002";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_stellenboschense_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_stellenboschense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_stellenboschense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_stellenboschense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762211"]),
        None,
        Some("."),
        Some("BSTEL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Achromobacter xylosoxidans A8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762376.AXYL_00001";
/// let this_library_node_name2 = "762376.AXYL_06895";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_achromobacter_xylosoxidans_a8_node_name(this_library_node_name1));
/// assert!(is_valid_string_achromobacter_xylosoxidans_a8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_achromobacter_xylosoxidans_a8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_achromobacter_xylosoxidans_a8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762376"]),
        None,
        Some("."),
        Some("AXYL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leuconostoc gasicomitatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762550.LEGAS_0001";
/// let this_library_node_name2 = "762550.LEGAS_1913";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leuconostoc_gasicomitatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_leuconostoc_gasicomitatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leuconostoc_gasicomitatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leuconostoc_gasicomitatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762550"]),
        None,
        Some("."),
        Some("LEGAS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pedobacter saltans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762903.Pedsa_0001";
/// let this_library_node_name2 = "762903.Pedsa_R0032";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pedobacter_saltans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pedobacter_saltans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pedobacter_saltans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pedobacter_saltans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762903"]),
        None,
        Some("."),
        Some("Pedsa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rothia dentocariosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762948.HMPREF0733_10001";
/// let this_library_node_name2 = "762948.HMPREF0733_12218";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rothia_dentocariosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_rothia_dentocariosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rothia_dentocariosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rothia_dentocariosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762948"]),
        None,
        Some("."),
        Some("HMPREF0733_1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. F0386 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762963.HMPREF9056_00001";
/// let this_library_node_name2 = "762963.HMPREF9056_03094";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_f0386_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_f0386_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_f0386_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_f0386_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762963"]),
        None,
        Some("."),
        Some("HMPREF9056_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parasutterella excrementihominis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762966.HMPREF9439_00001";
/// let this_library_node_name2 = "762966.HMPREF9439_02809";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parasutterella_excrementihominis_node_name(this_library_node_name1));
/// assert!(is_valid_string_parasutterella_excrementihominis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parasutterella_excrementihominis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parasutterella_excrementihominis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762966"]),
        None,
        Some("."),
        Some("HMPREF9439_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paraprevotella clara nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762968.HMPREF9441_00001";
/// let this_library_node_name2 = "762968.HMPREF9441_04074";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paraprevotella_clara_node_name(this_library_node_name1));
/// assert!(is_valid_string_paraprevotella_clara_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paraprevotella_clara_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paraprevotella_clara_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762968"]),
        None,
        Some("."),
        Some("HMPREF9441_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paraprevotella xylaniphila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762982.HMPREF9442_00001";
/// let this_library_node_name2 = "762982.HMPREF9442_03501";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paraprevotella_xylaniphila_node_name(this_library_node_name1));
/// assert!(is_valid_string_paraprevotella_xylaniphila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paraprevotella_xylaniphila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paraprevotella_xylaniphila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762982"]),
        None,
        Some("."),
        Some("HMPREF9442_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Succinatimonas hippei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762983.HMPREF9444_00002";
/// let this_library_node_name2 = "762983.HMPREF9444_02271";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_succinatimonas_hippei_node_name(this_library_node_name1));
/// assert!(is_valid_string_succinatimonas_hippei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_succinatimonas_hippei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_succinatimonas_hippei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762983"]),
        None,
        Some("."),
        Some("HMPREF9444_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides clarus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "762984.HMPREF9445_00001";
/// let this_library_node_name2 = "762984.HMPREF9445_03331";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_clarus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_clarus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_clarus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_clarus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["762984"]),
        None,
        Some("."),
        Some("HMPREF9445_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides fluxus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "763034.HMPREF9446_00001";
/// let this_library_node_name2 = "763034.HMPREF9446_03985";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_fluxus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_fluxus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_fluxus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_fluxus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["763034"]),
        None,
        Some("."),
        Some("HMPREF9446_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus urinalis 228597 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "764291.STRUR_0003";
/// let this_library_node_name2 = "764291.STRUR_2283";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_urinalis_228597_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_urinalis_228597_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_urinalis_228597_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_urinalis_228597_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["764291"]),
        None,
        Some("."),
        Some("STRUR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus macacae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "764298.STRMA_0001";
/// let this_library_node_name2 = "764298.STRMA_1972";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_macacae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_macacae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_macacae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_macacae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["764298"]),
        None,
        Some("."),
        Some("STRMA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus ictaluri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "764299.STRIC_0001";
/// let this_library_node_name2 = "764299.STRIC_2548";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_ictaluri_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_ictaluri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_ictaluri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_ictaluri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["764299"]),
        None,
        Some("."),
        Some("STRIC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium acnes HL037PA2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765123.HMPREF9621_00001";
/// let this_library_node_name2 = "765123.HMPREF9621_02909";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_acnes_hl037pa2_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_acnes_hl037pa2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_acnes_hl037pa2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_acnes_hl037pa2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765123"]),
        None,
        Some("."),
        Some("HMPREF9621_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfurococcus mucosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765177.Desmu_0001";
/// let this_library_node_name2 = "765177.Desmu_1371";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfurococcus_mucosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfurococcus_mucosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfurococcus_mucosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfurococcus_mucosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765177"]),
        None,
        Some("."),
        Some("Desmu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oscillochloris trichoides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765420.OSCT_0001";
/// let this_library_node_name2 = "765420.OSCT_3231";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oscillochloris_trichoides_node_name(this_library_node_name1));
/// assert!(is_valid_string_oscillochloris_trichoides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oscillochloris_trichoides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oscillochloris_trichoides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765420"]),
        None,
        Some("."),
        Some("OSCT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium ciceri biovar nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765698.Mesci_0001";
/// let this_library_node_name2 = "765698.Mesci_6470";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_ciceri_biovar_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_ciceri_biovar_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_ciceri_biovar_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_ciceri_biovar_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765698"]),
        None,
        Some("."),
        Some("Mesci_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bdellovibrio bacteriovorus W nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765869.BDW_00005";
/// let this_library_node_name2 = "765869.BDW_14405";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bdellovibrio_bacteriovorus_w_node_name(this_library_node_name1));
/// assert!(is_valid_string_bdellovibrio_bacteriovorus_w_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bdellovibrio_bacteriovorus_w_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bdellovibrio_bacteriovorus_w_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765869"]),
        None,
        Some("."),
        Some("BDW_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marichromatium purpuratum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765910.MARPU_00005";
/// let this_library_node_name2 = "765910.MARPU_16740";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marichromatium_purpuratum_node_name(this_library_node_name1));
/// assert!(is_valid_string_marichromatium_purpuratum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marichromatium_purpuratum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marichromatium_purpuratum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765910"]),
        None,
        Some("."),
        Some("MARPU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiocystis violascens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765911.Thivi_0001";
/// let this_library_node_name2 = "765911.Thivi_4631";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiocystis_violascens_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiocystis_violascens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiocystis_violascens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiocystis_violascens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765911"]),
        None,
        Some("."),
        Some("Thivi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioflavicoccus mobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765912.Thimo_0001";
/// let this_library_node_name2 = "765912.Thimo_3702";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioflavicoccus_mobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioflavicoccus_mobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioflavicoccus_mobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioflavicoccus_mobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765912"]),
        None,
        Some("."),
        Some("Thimo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiorhodococcus drewsii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765913.ThidrDRAFT_0001";
/// let this_library_node_name2 = "765913.ThidrDRAFT_4736";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiorhodococcus_drewsii_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiorhodococcus_drewsii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiorhodococcus_drewsii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiorhodococcus_drewsii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765913"]),
        None,
        Some("."),
        Some("ThidrDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiorhodospira sibirica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765914.ThisiDRAFT_0001";
/// let this_library_node_name2 = "765914.ThisiDRAFT_2959";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiorhodospira_sibirica_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiorhodospira_sibirica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiorhodospira_sibirica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiorhodospira_sibirica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765914"]),
        None,
        Some("."),
        Some("ThisiDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parachlamydia acanthamoebae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "765952.PUV_00010";
/// let this_library_node_name2 = "765952.PUV_27880";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parachlamydia_acanthamoebae_node_name(this_library_node_name1));
/// assert!(is_valid_string_parachlamydia_acanthamoebae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parachlamydia_acanthamoebae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parachlamydia_acanthamoebae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["765952"]),
        None,
        Some("."),
        Some("PUV_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citreicella sp. 357 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "766499.C357_00005";
/// let this_library_node_name2 = "766499.C357_23230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citreicella_sp_357_node_name(this_library_node_name1));
/// assert!(is_valid_string_citreicella_sp_357_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citreicella_sp_357_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citreicella_sp_357_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["766499"]),
        None,
        Some("."),
        Some("C357_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium propionicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "767029.HMPREF9154_0001";
/// let this_library_node_name2 = "767029.HMPREF9154_3193";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_propionicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_propionicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_propionicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_propionicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["767029"]),
        None,
        Some("."),
        Some("HMPREF9154_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella denticola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "767031.HMPREF9137_0001";
/// let this_library_node_name2 = "767031.HMPREF9137_2498";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_denticola_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_denticola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_denticola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_denticola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["767031"]),
        None,
        Some("."),
        Some("HMPREF9137_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frateuria aurantia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "767434.Fraau_0001";
/// let this_library_node_name2 = "767434.Fraau_3289";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frateuria_aurantia_node_name(this_library_node_name1));
/// assert!(is_valid_string_frateuria_aurantia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frateuria_aurantia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frateuria_aurantia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["767434"]),
        None,
        Some("."),
        Some("Fraau_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum gibsoniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "767817.Desgi_0001";
/// let this_library_node_name2 = "767817.Desgi_4763";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_gibsoniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_gibsoniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_gibsoniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_gibsoniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["767817"]),
        None,
        Some("."),
        Some("Desgi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas elongata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "768066.HELO_1001";
/// let this_library_node_name2 = "768066.HELO_4473";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_elongata_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_elongata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_elongata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_elongata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["768066"]),
        None,
        Some("."),
        Some("HELO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus hirae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "768486.EHR_00005";
/// let this_library_node_name2 = "768486.EHR_3115";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_hirae_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_hirae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_hirae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_hirae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["768486"]),
        None,
        Some("."),
        Some("EHR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Calditerrivibrio nitroreducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "768670.Calni_0001";
/// let this_library_node_name2 = "768670.Calni_2127";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_calditerrivibrio_nitroreducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_calditerrivibrio_nitroreducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_calditerrivibrio_nitroreducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_calditerrivibrio_nitroreducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["768670"]),
        None,
        Some("."),
        Some("Calni_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiocapsa marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "768671.ThimaDRAFT_0001";
/// let this_library_node_name2 = "768671.ThimaDRAFT_4926";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiocapsa_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiocapsa_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiocapsa_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiocapsa_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["768671"]),
        None,
        Some("."),
        Some("ThimaDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfurococcus fermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "768672.Desfe_0001";
/// let this_library_node_name2 = "768672.Desfe_1471";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfurococcus_fermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfurococcus_fermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfurococcus_fermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfurococcus_fermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["768672"]),
        None,
        Some("."),
        Some("Desfe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoproteus tenax nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "768679.TTX_0001";
/// let this_library_node_name2 = "768679.TTX_2117";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoproteus_tenax_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoproteus_tenax_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoproteus_tenax_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoproteus_tenax_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["768679"]),
        None,
        Some("."),
        Some("TTX_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfosporosinus meridiei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "768704.Desmer_0001";
/// let this_library_node_name2 = "768704.Desmer_4666";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfosporosinus_meridiei_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfosporosinus_meridiei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfosporosinus_meridiei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfosporosinus_meridiei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["768704"]),
        None,
        Some("."),
        Some("Desmer_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfosporosinus orientis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "768706.Desor_0001";
/// let this_library_node_name2 = "768706.Desor_5640";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfosporosinus_orientis_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfosporosinus_orientis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfosporosinus_orientis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfosporosinus_orientis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["768706"]),
        None,
        Some("."),
        Some("Desor_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfosporosinus youngiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "768710.DesyoDRAFT_0001";
/// let this_library_node_name2 = "768710.DesyoDRAFT_5457";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfosporosinus_youngiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfosporosinus_youngiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfosporosinus_youngiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfosporosinus_youngiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["768710"]),
        None,
        Some("."),
        Some("DesyoDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis 2 F0392 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "768726.HMPREF9178_0001";
/// let this_library_node_name2 = "768726.HMPREF9178_1962";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_2_f0392_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_2_f0392_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_2_f0392_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_2_f0392_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["768726"]),
        None,
        Some("."),
        Some("HMPREF9178_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fervidobacterium pennivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "771875.Ferpe_0001";
/// let this_library_node_name2 = "771875.Ferpe_2064";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fervidobacterium_pennivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_fervidobacterium_pennivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fervidobacterium_pennivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fervidobacterium_pennivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["771875"]),
        None,
        Some("."),
        Some("Ferpe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sinorhizobium sp. CCBAU05631 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "794846.AJQU01000001_gene1190";
/// let this_library_node_name2 = "794846.AJQU01000242_gene223";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sinorhizobium_sp_ccbau05631_node_name(this_library_node_name1));
/// assert!(is_valid_string_sinorhizobium_sp_ccbau05631_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sinorhizobium_sp_ccbau05631_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sinorhizobium_sp_ccbau05631_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["794846"]),
        None,
        Some("."),
        Some("AJQU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Opitutaceae bacterium TAV5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "794903.OPIT5_00005";
/// let this_library_node_name2 = "794903.OPIT5_30880";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_opitutaceae_bacterium_tav5_node_name(this_library_node_name1));
/// assert!(is_valid_string_opitutaceae_bacterium_tav5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_opitutaceae_bacterium_tav5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_opitutaceae_bacterium_tav5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["794903"]),
        None,
        Some("."),
        Some("OPIT5_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermodesulfobacterium geofontis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "795359.TOPB45_0001";
/// let this_library_node_name2 = "795359.TOPB45_1635";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermodesulfobacterium_geofontis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermodesulfobacterium_geofontis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermodesulfobacterium_geofontis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermodesulfobacterium_geofontis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["795359"]),
        None,
        Some("."),
        Some("TOPB45_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ralstonia sp. PBA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "795666.MW7_0001";
/// let this_library_node_name2 = "795666.MW7_3562";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ralstonia_sp_pba_node_name(this_library_node_name1));
/// assert!(is_valid_string_ralstonia_sp_pba_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ralstonia_sp_pba_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ralstonia_sp_pba_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["795666"]),
        None,
        Some("."),
        Some("MW7_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halalkalicoccus jeotgali nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "795797.C497_00005";
/// let this_library_node_name2 = "795797.C497_19419";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halalkalicoccus_jeotgali_node_name(this_library_node_name1));
/// assert!(is_valid_string_halalkalicoccus_jeotgali_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halalkalicoccus_jeotgali_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halalkalicoccus_jeotgali_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["795797"]),
        None,
        Some("."),
        Some("C497_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nesterenkonia sp. F nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "795955.AFRW01000001_gene1422";
/// let this_library_node_name2 = "795955.AFRW01000137_gene797";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nesterenkonia_sp_f_node_name(this_library_node_name1));
/// assert!(is_valid_string_nesterenkonia_sp_f_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nesterenkonia_sp_f_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nesterenkonia_sp_f_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["795955"]),
        None,
        Some("."),
        Some("AFRW01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus methanolicus MGA3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "796606.BMMGA3_00005";
/// let this_library_node_name2 = "796606.BMMGA3_17175";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_methanolicus_mga3_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_methanolicus_mga3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_methanolicus_mga3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_methanolicus_mga3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["796606"]),
        None,
        Some("."),
        Some("BMMGA3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio caribbeanicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "796620.VIBC2010_00005";
/// let this_library_node_name2 = "796620.VIBC2010_20385";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_caribbeanicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_caribbeanicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_caribbeanicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_caribbeanicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["796620"]),
        None,
        Some("."),
        Some("VIBC2010_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptostreptococcaceae bacterium CM5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "796940.HMPREF9628_00001";
/// let this_library_node_name2 = "796940.HMPREF9628_02325";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptostreptococcaceae_bacterium_cm5_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptostreptococcaceae_bacterium_cm5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptostreptococcaceae_bacterium_cm5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptostreptococcaceae_bacterium_cm5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["796940"]),
        None,
        Some("."),
        Some("HMPREF9628_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stomatobaculum longum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "796942.HMPREF9623_00001";
/// let this_library_node_name2 = "796942.HMPREF9623_02071";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stomatobaculum_longum_node_name(this_library_node_name1));
/// assert!(is_valid_string_stomatobaculum_longum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stomatobaculum_longum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stomatobaculum_longum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["796942"]),
        None,
        Some("."),
        Some("HMPREF9623_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oribacterium parvum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "796945.HMPREF1145_0001";
/// let this_library_node_name2 = "796945.HMPREF1145_2291";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oribacterium_parvum_node_name(this_library_node_name1));
/// assert!(is_valid_string_oribacterium_parvum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oribacterium_parvum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oribacterium_parvum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["796945"]),
        None,
        Some("."),
        Some("HMPREF1145_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halosimplex carlsbadense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "797114.C475_00005";
/// let this_library_node_name2 = "797114.C475_22444";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halosimplex_carlsbadense_node_name(this_library_node_name1));
/// assert!(is_valid_string_halosimplex_carlsbadense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halosimplex_carlsbadense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halosimplex_carlsbadense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["797114"]),
        None,
        Some("."),
        Some("C475_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haladaptatus paucihalophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "797209.ZOD2009_00005";
/// let this_library_node_name2 = "797209.ZOD2009_22357";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haladaptatus_paucihalophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_haladaptatus_paucihalophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haladaptatus_paucihalophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haladaptatus_paucihalophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["797209"]),
        None,
        Some("."),
        Some("ZOD2009_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halopiger xanaduensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "797210.Halxa_0001";
/// let this_library_node_name2 = "797210.Halxa_4310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halopiger_xanaduensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_halopiger_xanaduensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halopiger_xanaduensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halopiger_xanaduensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["797210"]),
        None,
        Some("."),
        Some("Halxa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halostagnicola larsenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "797299.HALLA_00005";
/// let this_library_node_name2 = "797299.HALLA_21320";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halostagnicola_larsenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_halostagnicola_larsenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halostagnicola_larsenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halostagnicola_larsenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["797299"]),
        None,
        Some("."),
        Some("HALLA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halovivax ruber nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "797302.Halru_0001";
/// let this_library_node_name2 = "797302.Halru_3189";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halovivax_ruber_node_name(this_library_node_name1));
/// assert!(is_valid_string_halovivax_ruber_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halovivax_ruber_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halovivax_ruber_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["797302"]),
        None,
        Some("."),
        Some("Halru_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natrinema pellirubrum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "797303.Natpe_0001";
/// let this_library_node_name2 = "797303.Natpe_4200";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natrinema_pellirubrum_node_name(this_library_node_name1));
/// assert!(is_valid_string_natrinema_pellirubrum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natrinema_pellirubrum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natrinema_pellirubrum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["797303"]),
        None,
        Some("."),
        Some("Natpe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natronobacterium gregoryi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "797304.Natgr_0001";
/// let this_library_node_name2 = "797304.Natgr_3836";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natronobacterium_gregoryi_node_name(this_library_node_name1));
/// assert!(is_valid_string_natronobacterium_gregoryi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natronobacterium_gregoryi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natronobacterium_gregoryi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["797304"]),
        None,
        Some("."),
        Some("Natgr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus parafarraginis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "797515.HMPREF9103_00001";
/// let this_library_node_name2 = "797515.HMPREF9103_03222";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_parafarraginis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_parafarraginis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_parafarraginis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_parafarraginis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["797515"]),
        None,
        Some("."),
        Some("HMPREF9103_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiroplasma mirum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "838561.P344_00005";
/// let this_library_node_name2 = "838561.P344_07185";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiroplasma_mirum_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiroplasma_mirum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiroplasma_mirum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiroplasma_mirum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["838561"]),
        None,
        Some("."),
        Some("P344_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Micavibrio aeruginosavorus ARL13 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "856793.MICA_1";
/// let this_library_node_name2 = "856793.MICA_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_micavibrio_aeruginosavorus_arl13_node_name(this_library_node_name1));
/// assert!(is_valid_string_micavibrio_aeruginosavorus_arl13_node_name(this_library_node_name2));
/// assert!(!is_valid_string_micavibrio_aeruginosavorus_arl13_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_micavibrio_aeruginosavorus_arl13_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["856793"]),
        None,
        Some("."),
        Some("MICA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylomonas methanica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "857087.Metme_0001";
/// let this_library_node_name2 = "857087.Metme_4614";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylomonas_methanica_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylomonas_methanica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylomonas_methanica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylomonas_methanica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["857087"]),
        None,
        Some("."),
        Some("Metme_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Scardovia wiggsiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "857290.HMPREF9156_00001";
/// let this_library_node_name2 = "857290.HMPREF9156_01243";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_scardovia_wiggsiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_scardovia_wiggsiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_scardovia_wiggsiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_scardovia_wiggsiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["857290"]),
        None,
        Some("."),
        Some("HMPREF9156_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caloramator australicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "857293.CAAU_0001";
/// let this_library_node_name2 = "857293.CAAU_2730";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caloramator_australicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_caloramator_australicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caloramator_australicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caloramator_australicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["857293"]),
        None,
        Some("."),
        Some("CAAU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moraxella catarrhalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "857571.EA1_00005";
/// let this_library_node_name2 = "857571.EA1_08959";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moraxella_catarrhalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_moraxella_catarrhalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moraxella_catarrhalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moraxella_catarrhalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["857571"]),
        None,
        Some("."),
        Some("EA1_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoanaerobacterium xylanolyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "858215.Thexy_0001";
/// let this_library_node_name2 = "858215.Thexy_2415";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoanaerobacterium_xylanolyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoanaerobacterium_xylanolyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoanaerobacterium_xylanolyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoanaerobacterium_xylanolyticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["858215"]),
        None,
        Some("."),
        Some("Thexy_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium variabile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "858619.CVAR_0001";
/// let this_library_node_name2 = "858619.CVAR_3080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_variabile_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_variabile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_variabile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_variabile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["858619"]),
        None,
        Some("."),
        Some("CVAR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma haemofelis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "859194.MHF_0001";
/// let this_library_node_name2 = "859194.MHF_1616";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_haemofelis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_haemofelis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_haemofelis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_haemofelis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["859194"]),
        None,
        Some("."),
        Some("MHF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING alpha proteobacterium HIMB5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "859653.HIMB5_00000010";
/// let this_library_node_name2 = "859653.HIMB5_00014670";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alpha_proteobacterium_himb5_node_name(this_library_node_name1));
/// assert!(is_valid_string_alpha_proteobacterium_himb5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alpha_proteobacterium_himb5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alpha_proteobacterium_himb5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["859653"]),
        None,
        Some("."),
        Some("HIMB5_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ralstonia solanacearum PSI07 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "859657.RPSI07_0001";
/// let this_library_node_name2 = "859657.RPSI07_mp1794";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ralstonia_solanacearum_psi07_node_name(this_library_node_name1));
/// assert!(is_valid_string_ralstonia_solanacearum_psi07_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ralstonia_solanacearum_psi07_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ralstonia_solanacearum_psi07_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["859657"]),
        None,
        Some("."),
        Some("RPSI07_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga canimorsus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "860228.Ccan_00010";
/// let this_library_node_name2 = "860228.Ccan_24140";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_canimorsus_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_canimorsus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_canimorsus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_canimorsus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["860228"]),
        None,
        Some("."),
        Some("Ccan_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agrobacterium sp. H133 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "861208.AGROH133_02802";
/// let this_library_node_name2 = "861208.AGROH133_15373";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agrobacterium_sp_h133_node_name(this_library_node_name1));
/// assert!(is_valid_string_agrobacterium_sp_h133_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agrobacterium_sp_h133_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agrobacterium_sp_h133_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["861208"]),
        None,
        Some("."),
        Some("AGROH133_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemmatimonadetes bacterium KBS708 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "861299.J421_0001";
/// let this_library_node_name2 = "861299.J421_6372";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemmatimonadetes_bacterium_kbs708_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemmatimonadetes_bacterium_kbs708_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemmatimonadetes_bacterium_kbs708_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemmatimonadetes_bacterium_kbs708_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["861299"]),
        None,
        Some("."),
        Some("J421_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter arilaitensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "861360.AARI_00010";
/// let this_library_node_name2 = "861360.AARI_pI00500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_arilaitensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_arilaitensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_arilaitensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_arilaitensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["861360"]),
        None,
        Some("."),
        Some("AARI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaeroglobus geminatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "861450.HMPREF0080_00001";
/// let this_library_node_name2 = "861450.HMPREF0080_02200";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaeroglobus_geminatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaeroglobus_geminatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaeroglobus_geminatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaeroglobus_geminatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["861450"]),
        None,
        Some("."),
        Some("HMPREF0080_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium sp. F0437 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "861452.HMPREF9093_00001";
/// let this_library_node_name2 = "861452.HMPREF9093_02314";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_sp_f0437_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_sp_f0437_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_sp_f0437_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_sp_f0437_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["861452"]),
        None,
        Some("."),
        Some("HMPREF9093_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium F0431 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "861454.HMPREF9099_00001";
/// let this_library_node_name2 = "861454.HMPREF9099_03168";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_f0431_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_f0431_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_f0431_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_f0431_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["861454"]),
        None,
        Some("."),
        Some("HMPREF9099_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. F0407 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "861455.HMPREF9184_00001";
/// let this_library_node_name2 = "861455.HMPREF9184_01916";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_f0407_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_f0407_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_f0407_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_f0407_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["861455"]),
        None,
        Some("."),
        Some("HMPREF9184_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus sp. AL1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "861530.ALOZ01000001_gene794";
/// let this_library_node_name2 = "861530.ALOZ01000076_gene1208";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_sp_al1_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_sp_al1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_sp_al1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_sp_al1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["861530"]),
        None,
        Some("."),
        Some("ALOZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pediococcus acidilactici DSM20284 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "862514.HMPREF0623_0001";
/// let this_library_node_name2 = "862514.HMPREF0623_1884";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pediococcus_acidilactici_dsm20284_node_name(this_library_node_name1));
/// assert!(is_valid_string_pediococcus_acidilactici_dsm20284_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pediococcus_acidilactici_dsm20284_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pediococcus_acidilactici_dsm20284_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["862514"]),
        None,
        Some("."),
        Some("HMPREF0623_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella marshii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "862515.HMPREF0658_0001";
/// let this_library_node_name2 = "862515.HMPREF0658_2340";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_marshii_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_marshii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_marshii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_marshii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["862515"]),
        None,
        Some("."),
        Some("HMPREF0658_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus duerdenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "862517.HMPREF9225_0001";
/// let this_library_node_name2 = "862517.HMPREF9225_1988";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_duerdenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_duerdenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_duerdenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_duerdenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["862517"]),
        None,
        Some("."),
        Some("HMPREF9225_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. SirexAAE nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "862751.SACTE_0001";
/// let this_library_node_name2 = "862751.SACTE_6562";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_sirexaae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_sirexaae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_sirexaae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_sirexaae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["862751"]),
        None,
        Some("."),
        Some("SACTE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteriovorax marinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "862908.410610417";
/// let this_library_node_name2 = "862908.BMS_3450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteriovorax_marinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteriovorax_marinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteriovorax_marinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteriovorax_marinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["862908"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haemophilus parainfluenzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "862965.301155057";
/// let this_library_node_name2 = "862965.PARA_20010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haemophilus_parainfluenzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_haemophilus_parainfluenzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haemophilus_parainfluenzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haemophilus_parainfluenzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["862965"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus intermedius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "862967.SIR_0001";
/// let this_library_node_name2 = "862967.SIR_1905";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_intermedius_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_intermedius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_intermedius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_intermedius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["862967"]),
        None,
        Some("."),
        Some("SIR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus constellatus pharyngis C1050 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "862969.SCI_0001";
/// let this_library_node_name2 = "862969.SCI_1943";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_constellatus_pharyngis_c1050_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_constellatus_pharyngis_c1050_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_constellatus_pharyngis_c1050_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_constellatus_pharyngis_c1050_node_name(
    node_name: &str,
) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["862969"]),
        None,
        Some("."),
        Some("SCI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus anginosus C1051 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "862970.SAIN_0001";
/// let this_library_node_name2 = "862970.SAIN_1839";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_anginosus_c1051_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_anginosus_c1051_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_anginosus_c1051_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_anginosus_c1051_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["862970"]),
        None,
        Some("."),
        Some("SAIN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus anginosus C238 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "862971.SANR_0001";
/// let this_library_node_name2 = "862971.SANR_2126";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_anginosus_c238_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_anginosus_c238_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_anginosus_c238_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_anginosus_c238_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["862971"]),
        None,
        Some("."),
        Some("SANR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium nuruki nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "863239.AFIZ01000001_gene147";
/// let this_library_node_name2 = "863239.AFIZ01000068_gene1449";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_nuruki_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_nuruki_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_nuruki_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_nuruki_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["863239"]),
        None,
        Some("."),
        Some("AFIZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas hortorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "863365.XHC_0001";
/// let this_library_node_name2 = "863365.XHC_4493";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_hortorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_hortorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_hortorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_hortorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["863365"]),
        None,
        Some("."),
        Some("XHC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderiales bacterium JOSHI001 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "864051.BurJ1DRAFT_0001";
/// let this_library_node_name2 = "864051.BurJ1DRAFT_5023";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderiales_bacterium_joshi001_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderiales_bacterium_joshi001_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderiales_bacterium_joshi001_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderiales_bacterium_joshi001_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["864051"]),
        None,
        Some("."),
        Some("BurJ1DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microvirga lotononidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "864069.MicloDRAFT_00000010";
/// let this_library_node_name2 = "864069.MicloDRAFT_00070490";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microvirga_lotononidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_microvirga_lotononidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microvirga_lotononidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microvirga_lotononidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["864069"]),
        None,
        Some("."),
        Some("MicloDRAFT_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Herbaspirillum frisingense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "864073.HFRIS_000005";
/// let this_library_node_name2 = "864073.HFRIS_024521";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_herbaspirillum_frisingense_node_name(this_library_node_name1));
/// assert!(is_valid_string_herbaspirillum_frisingense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_herbaspirillum_frisingense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_herbaspirillum_frisingense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["864073"]),
        None,
        Some("."),
        Some("HFRIS_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas sp. 67H29BP nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "864563.HMPREF9166_0001";
/// let this_library_node_name2 = "864563.HMPREF9166_2408";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_sp_67h29bp_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_sp_67h29bp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_sp_67h29bp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_sp_67h29bp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["864563"]),
        None,
        Some("."),
        Some("HMPREF9166_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parascardovia denticolens DSM10105 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "864564.HMPREF0620_0001";
/// let this_library_node_name2 = "864564.HMPREF0620_1680";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parascardovia_denticolens_dsm10105_node_name(this_library_node_name1));
/// assert!(is_valid_string_parascardovia_denticolens_dsm10105_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parascardovia_denticolens_dsm10105_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parascardovia_denticolens_dsm10105_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["864564"]),
        None,
        Some("."),
        Some("HMPREF0620_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium yurii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "864565.HMPREF0379_0001";
/// let this_library_node_name2 = "864565.HMPREF0379_2134";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_yurii_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_yurii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_yurii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_yurii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["864565"]),
        None,
        Some("."),
        Some("HMPREF0379_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis ATCC6249 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "864567.HMPREF8571_0001";
/// let this_library_node_name2 = "864567.HMPREF8571_1793";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_atcc6249_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_atcc6249_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_atcc6249_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_atcc6249_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["864567"]),
        None,
        Some("."),
        Some("HMPREF8571_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. 73H25AP nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "864570.HMPREF9189_0001";
/// let this_library_node_name2 = "864570.HMPREF9189_1924";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_73h25ap_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_73h25ap_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_73h25ap_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_73h25ap_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["864570"]),
        None,
        Some("."),
        Some("HMPREF9189_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oscillatoriales cyanobacterium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "864702.OsccyDRAFT_0001";
/// let this_library_node_name2 = "864702.OsccyDRAFT_5082";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oscillatoriales_cyanobacterium_node_name(this_library_node_name1));
/// assert!(is_valid_string_oscillatoriales_cyanobacterium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oscillatoriales_cyanobacterium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oscillatoriales_cyanobacterium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["864702"]),
        None,
        Some("."),
        Some("OsccyDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium ultunense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "865861.AZSU01000001_gene1";
/// let this_library_node_name2 = "865861.AZSU01000012_gene1489";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_ultunense_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_ultunense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_ultunense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_ultunense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["865861"]),
        None,
        Some("."),
        Some("AZSU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gillisia limnaea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "865937.Gilli_0002";
/// let this_library_node_name2 = "865937.Gilli_R0011";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gillisia_limnaea_node_name(this_library_node_name1));
/// assert!(is_valid_string_gillisia_limnaea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gillisia_limnaea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gillisia_limnaea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["865937"]),
        None,
        Some("."),
        Some("Gilli_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Weeksella virosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "865938.Weevi_0001";
/// let this_library_node_name2 = "865938.Weevi_R0033";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_weeksella_virosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_weeksella_virosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_weeksella_virosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_weeksella_virosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["865938"]),
        None,
        Some("."),
        Some("Weevi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Belliella baltica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "866536.Belba_0001";
/// let this_library_node_name2 = "866536.Belba_3880";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_belliella_baltica_node_name(this_library_node_name1));
/// assert!(is_valid_string_belliella_baltica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_belliella_baltica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_belliella_baltica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["866536"]),
        None,
        Some("."),
        Some("Belba_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Schizosaccharomyces cryophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "866546.EPY49146";
/// let this_library_node_name2 = "866546.EPY54325";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_schizosaccharomyces_cryophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_schizosaccharomyces_cryophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_schizosaccharomyces_cryophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_schizosaccharomyces_cryophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["866546"]),
        None,
        Some("."),
        Some("EPY"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella disiens FB03509AN nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "866771.HMPREF9296_0002";
/// let this_library_node_name2 = "866771.HMPREF9296_2702";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_disiens_fb03509an_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_disiens_fb03509an_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_disiens_fb03509an_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_disiens_fb03509an_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["866771"]),
        None,
        Some("."),
        Some("HMPREF9296_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atopobium vaginae PB189T14 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "866774.HMPREF9248_0001";
/// let this_library_node_name2 = "866774.HMPREF9248_1273";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atopobium_vaginae_pb189t14_node_name(this_library_node_name1));
/// assert!(is_valid_string_atopobium_vaginae_pb189t14_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atopobium_vaginae_pb189t14_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atopobium_vaginae_pb189t14_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["866774"]),
        None,
        Some("."),
        Some("HMPREF9248_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aerococcus urinae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "866775.HMPREF9243_0001";
/// let this_library_node_name2 = "866775.HMPREF9243_2058";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aerococcus_urinae_node_name(this_library_node_name1));
/// assert!(is_valid_string_aerococcus_urinae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aerococcus_urinae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aerococcus_urinae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["866775"]),
        None,
        Some("."),
        Some("HMPREF9243_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Veillonella atypica ACS049VSch6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "866776.HMPREF9321_0001";
/// let this_library_node_name2 = "866776.HMPREF9321_1914";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_veillonella_atypica_acs049vsch6_node_name(this_library_node_name1));
/// assert!(is_valid_string_veillonella_atypica_acs049vsch6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_veillonella_atypica_acs049vsch6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_veillonella_atypica_acs049vsch6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["866776"]),
        None,
        Some("."),
        Some("HMPREF9321_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halobacillus halophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "866895.HBHAL_1001";
/// let this_library_node_name2 = "866895.HBHAL_5173";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halobacillus_halophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_halobacillus_halophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halobacillus_halophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halobacillus_halophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["866895"]),
        None,
        Some("."),
        Some("HBHAL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chloroflexus sp. Y3961 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "867845.KI911784_gene1";
/// let this_library_node_name2 = "867845.KI911784_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chloroflexus_sp_y3961_node_name(this_library_node_name1));
/// assert!(is_valid_string_chloroflexus_sp_y3961_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chloroflexus_sp_y3961_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chloroflexus_sp_y3961_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["867845"]),
        None,
        Some("."),
        Some("KI911784_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellulophaga lytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "867900.Celly_0001";
/// let this_library_node_name2 = "867900.Celly_3303";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellulophaga_lytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellulophaga_lytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellulophaga_lytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellulophaga_lytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["867900"]),
        None,
        Some("."),
        Some("Celly_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ornithobacterium rhinotracheale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "867902.Ornrh_0001";
/// let this_library_node_name2 = "867902.Ornrh_2372";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ornithobacterium_rhinotracheale_node_name(this_library_node_name1));
/// assert!(is_valid_string_ornithobacterium_rhinotracheale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ornithobacterium_rhinotracheale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ornithobacterium_rhinotracheale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["867902"]),
        None,
        Some("."),
        Some("Ornrh_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermaerobacter subterraneus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "867903.ThesuDRAFT_00001";
/// let this_library_node_name2 = "867903.ThesuDRAFT_02422";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermaerobacter_subterraneus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermaerobacter_subterraneus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermaerobacter_subterraneus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermaerobacter_subterraneus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["867903"]),
        None,
        Some("."),
        Some("ThesuDRAFT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanobacterium paludis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "868131.MSWAN_0001";
/// let this_library_node_name2 = "868131.MSWAN_2444";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanobacterium_paludis_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanobacterium_paludis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanobacterium_paludis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanobacterium_paludis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["868131"]),
        None,
        Some("."),
        Some("MSWAN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum carboxydivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "868595.Desca_0001";
/// let this_library_node_name2 = "868595.Desca_2747";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_carboxydivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_carboxydivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_carboxydivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_carboxydivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["868595"]),
        None,
        Some("."),
        Some("Desca_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfurobacterium thermolithotrophum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "868864.Dester_0001";
/// let this_library_node_name2 = "868864.Dester_1543";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfurobacterium_thermolithotrophum_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfurobacterium_thermolithotrophum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfurobacterium_thermolithotrophum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfurobacterium_thermolithotrophum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["868864"]),
        None,
        Some("."),
        Some("Dester_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema succinifaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "869209.Tresu_0001";
/// let this_library_node_name2 = "869209.Tresu_R0025";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_succinifaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_succinifaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_succinifaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_succinifaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["869209"]),
        None,
        Some("."),
        Some("Tresu_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinithermus hydrothermalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "869210.Marky_0001";
/// let this_library_node_name2 = "869210.Marky_R0048";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinithermus_hydrothermalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinithermus_hydrothermalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinithermus_hydrothermalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinithermus_hydrothermalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["869210"]),
        None,
        Some("."),
        Some("Marky_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cytophaga fermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "869213.JCM21142_1";
/// let this_library_node_name2 = "869213.JCM21142_99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cytophaga_fermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_cytophaga_fermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cytophaga_fermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cytophaga_fermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["869213"]),
        None,
        Some("."),
        Some("JCM21142_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiothrix nivea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "870187.Thini_0001";
/// let this_library_node_name2 = "870187.Thini_4542";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiothrix_nivea_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiothrix_nivea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiothrix_nivea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiothrix_nivea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["870187"]),
        None,
        Some("."),
        Some("Thini_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio scophthalmi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "870967.VIS19158_00005";
/// let this_library_node_name2 = "870967.VIS19158_23327";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_scophthalmi_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_scophthalmi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_scophthalmi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_scophthalmi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["870967"]),
        None,
        Some("."),
        Some("VIS19158_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter calcoaceticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "871585.BDGL_000001";
/// let this_library_node_name2 = "871585.BDGL_003599";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_calcoaceticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_calcoaceticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_calcoaceticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_calcoaceticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["871585"]),
        None,
        Some("."),
        Some("BDGL_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfitobacterium dichloroeliminans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "871963.Desdi_0001";
/// let this_library_node_name2 = "871963.Desdi_3535";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfitobacterium_dichloroeliminans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfitobacterium_dichloroeliminans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfitobacterium_dichloroeliminans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfitobacterium_dichloroeliminans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["871963"]),
        None,
        Some("."),
        Some("Desdi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfitobacterium metallireducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "871968.DESME_00005";
/// let this_library_node_name2 = "871968.DESME_15905";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfitobacterium_metallireducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfitobacterium_metallireducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfitobacterium_metallireducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfitobacterium_metallireducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["871968"]),
        None,
        Some("."),
        Some("DESME_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus parauberis NCFD2020 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "873447.SPB_0001";
/// let this_library_node_name2 = "873447.SPB_2238";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_parauberis_ncfd2020_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_parauberis_ncfd2020_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_parauberis_ncfd2020_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_parauberis_ncfd2020_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["873447"]),
        None,
        Some("."),
        Some("SPB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus porcinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "873448.STRPO_0001";
/// let this_library_node_name2 = "873448.STRPO_2050";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_porcinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_porcinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_porcinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_porcinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["873448"]),
        None,
        Some("."),
        Some("STRPO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus criceti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "873449.STRCR_0001";
/// let this_library_node_name2 = "873449.STRCR_2367";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_criceti_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_criceti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_criceti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_criceti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["873449"]),
        None,
        Some("."),
        Some("STRCR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella buccae ATCC33574 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "873513.HMPREF6485_0001";
/// let this_library_node_name2 = "873513.HMPREF6485_2898";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_buccae_atcc33574_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_buccae_atcc33574_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_buccae_atcc33574_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_buccae_atcc33574_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["873513"]),
        None,
        Some("."),
        Some("HMPREF6485_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga ochracea F0287 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "873517.HMPREF1977_0001";
/// let this_library_node_name2 = "873517.HMPREF1977_2333";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_ochracea_f0287_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_ochracea_f0287_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_ochracea_f0287_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_ochracea_f0287_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["873517"]),
        None,
        Some("."),
        Some("HMPREF1977_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella oralis ATCC33269 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "873533.HMPREF0663_10001";
/// let this_library_node_name2 = "873533.HMPREF0663_12489";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_oralis_atcc33269_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_oralis_atcc33269_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_oralis_atcc33269_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_oralis_atcc33269_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["873533"]),
        None,
        Some("."),
        Some("HMPREF0663_1"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium sp. JDM601 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "875328.JDM601_0001";
/// let this_library_node_name2 = "875328.JDM601_4346";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_sp_jdm601_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_sp_jdm601_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_sp_jdm601_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_sp_jdm601_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["875328"]),
        None,
        Some("."),
        Some("JDM601_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus rhinitidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "875454.BAEW01000001_gene1";
/// let this_library_node_name2 = "875454.BAEW01000054_gene1849";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_rhinitidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_rhinitidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_rhinitidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_rhinitidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["875454"]),
        None,
        Some("."),
        Some("BAEW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium IMCC3088 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "876044.IMCC3088_1";
/// let this_library_node_name2 = "876044.IMCC3088_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_imcc3088_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_imcc3088_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_imcc3088_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_imcc3088_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["876044"]),
        None,
        Some("."),
        Some("IMCC3088_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methyloferula stellata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "876269.ARWA01000001_gene1";
/// let this_library_node_name2 = "876269.ARWA01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methyloferula_stellata_node_name(this_library_node_name1));
/// assert!(is_valid_string_methyloferula_stellata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methyloferula_stellata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methyloferula_stellata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["876269"]),
        None,
        Some("."),
        Some("ARWA01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus sp. NK3A76 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "877411.JMMA01000001_gene1";
/// let this_library_node_name2 = "877411.JMMA01000002_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_sp_nk3a76_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_sp_nk3a76_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_sp_nk3a76_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_sp_nk3a76_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["877411"]),
        None,
        Some("."),
        Some("JMMA0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium NK3B98 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "877414.ATWA01000001_gene1000";
/// let this_library_node_name2 = "877414.ATWA01000200_gene1338";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_nk3b98_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_nk3b98_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_nk3b98_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_nk3b98_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["877414"]),
        None,
        Some("."),
        Some("ATWA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erysipelotrichaceae bacterium NK3D112 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "877415.JNJQ01000001_gene1911";
/// let this_library_node_name2 = "877415.JNJQ01000097_gene551";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erysipelotrichaceae_bacterium_nk3d112_node_name(this_library_node_name1));
/// assert!(is_valid_string_erysipelotrichaceae_bacterium_nk3d112_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erysipelotrichaceae_bacterium_nk3d112_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erysipelotrichaceae_bacterium_nk3d112_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["877415"]),
        None,
        Some("."),
        Some("JNJQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema bryantii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "877418.ATWV01000001_gene1424";
/// let this_library_node_name2 = "877418.ATWV01000028_gene857";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_bryantii_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_bryantii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_bryantii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_bryantii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["877418"]),
        None,
        Some("."),
        Some("ATWV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium NK4A136 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "877420.ATVW01000001_gene1937";
/// let this_library_node_name2 = "877420.ATVW01000077_gene350";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_nk4a136_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_nk4a136_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_nk4a136_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_nk4a136_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["877420"]),
        None,
        Some("."),
        Some("ATVW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium NK4A144 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "877421.AUJT01000001_gene1588";
/// let this_library_node_name2 = "877421.AUJT01000071_gene1010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_nk4a144_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_nk4a144_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_nk4a144_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_nk4a144_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["877421"]),
        None,
        Some("."),
        Some("AUJT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium NK4A179 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "877424.ATWC01000001_gene1870";
/// let this_library_node_name2 = "877424.ATWC01000073_gene720";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_nk4a179_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_nk4a179_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_nk4a179_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_nk4a179_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["877424"]),
        None,
        Some("."),
        Some("ATWC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanobacterium lacus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "877455.Metbo_0001";
/// let this_library_node_name2 = "877455.Metbo_2533";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanobacterium_lacus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanobacterium_lacus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanobacterium_lacus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanobacterium_lacus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["877455"]),
        None,
        Some("."),
        Some("Metbo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfobacter postgatei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "879212.DespoDRAFT_00001";
/// let this_library_node_name2 = "879212.DespoDRAFT_03773";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfobacter_postgatei_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfobacter_postgatei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfobacter_postgatei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfobacter_postgatei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["879212"]),
        None,
        Some("."),
        Some("DespoDRAFT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas asaccharolytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "879243.Poras_0001";
/// let this_library_node_name2 = "879243.Poras_R0006";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_asaccharolytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_asaccharolytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_asaccharolytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_asaccharolytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["879243"]),
        None,
        Some("."),
        Some("Poras_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerococcus prevotii ACS065VCol13 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "879305.HMPREF9290_0001";
/// let this_library_node_name2 = "879305.HMPREF9290_1706";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerococcus_prevotii_acs065vcol13_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerococcus_prevotii_acs065vcol13_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerococcus_prevotii_acs065vcol13_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerococcus_prevotii_acs065vcol13_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["879305"]),
        None,
        Some("."),
        Some("HMPREF9290_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus sp. F0436 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "879308.HMPREF9130_0001";
/// let this_library_node_name2 = "879308.HMPREF9130_2249";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_sp_f0436_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_sp_f0436_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_sp_f0436_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_sp_f0436_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["879308"]),
        None,
        Some("."),
        Some("HMPREF9130_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Veillonella sp. F0412 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "879309.HMPREF9199_0001";
/// let this_library_node_name2 = "879309.HMPREF9199_2076";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_veillonella_sp_f0412_node_name(this_library_node_name1));
/// assert!(is_valid_string_veillonella_sp_f0412_node_name(this_library_node_name2));
/// assert!(!is_valid_string_veillonella_sp_f0412_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_veillonella_sp_f0412_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["879309"]),
        None,
        Some("."),
        Some("HMPREF9199_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas sp. F0430 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "879310.HMPREF9162_0001";
/// let this_library_node_name2 = "879310.HMPREF9162_2481";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_sp_f0430_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_sp_f0430_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_sp_f0430_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_sp_f0430_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["879310"]),
        None,
        Some("."),
        Some("HMPREF9162_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyclobacterium marinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "880070.Cycma_0001";
/// let this_library_node_name2 = "880070.Cycma_5101";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyclobacterium_marinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyclobacterium_marinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyclobacterium_marinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyclobacterium_marinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["880070"]),
        None,
        Some("."),
        Some("Cycma_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flexibacter litoralis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "880071.Fleli_0001";
/// let this_library_node_name2 = "880071.Fleli_4094";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flexibacter_litoralis_node_name(this_library_node_name1));
/// assert!(is_valid_string_flexibacter_litoralis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flexibacter_litoralis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flexibacter_litoralis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["880071"]),
        None,
        Some("."),
        Some("Fleli_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfobacca acetoxidans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "880072.Desac_0001";
/// let this_library_node_name2 = "880072.Desac_2969";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfobacca_acetoxidans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfobacca_acetoxidans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfobacca_acetoxidans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfobacca_acetoxidans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["880072"]),
        None,
        Some("."),
        Some("Desac_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldithrix abyssi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "880073.Calab_0001";
/// let this_library_node_name2 = "880073.Calab_3808";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldithrix_abyssi_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldithrix_abyssi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldithrix_abyssi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldithrix_abyssi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["880073"]),
        None,
        Some("."),
        Some("Calab_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Barnesiella viscericola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "880074.BARVI_00005";
/// let this_library_node_name2 = "880074.BARVI_13110";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_barnesiella_viscericola_node_name(this_library_node_name1));
/// assert!(is_valid_string_barnesiella_viscericola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_barnesiella_viscericola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_barnesiella_viscericola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["880074"]),
        None,
        Some("."),
        Some("BARVI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma leachii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "880447.MSB_A0001";
/// let this_library_node_name2 = "880447.MSB_A0931";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_leachii_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_leachii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_leachii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_leachii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["880447"]),
        None,
        Some("."),
        Some("MSB_A0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rikenella microfusus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "880526.KE386488_gene1";
/// let this_library_node_name2 = "880526.KE386488_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rikenella_microfusus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rikenella_microfusus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rikenella_microfusus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rikenella_microfusus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["880526"]),
        None,
        Some("."),
        Some("KE386488_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeria ivanovii PAM55 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "881621.LIV_0001";
/// let this_library_node_name2 = "881621.LIV_2782";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeria_ivanovii_pam55_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeria_ivanovii_pam55_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeria_ivanovii_pam55_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeria_ivanovii_pam55_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["881621"]),
        None,
        Some("."),
        Some("LIV_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharomonospora cyanea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "882082.SaccyDRAFT_0001";
/// let this_library_node_name2 = "882082.SaccyDRAFT_5197";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharomonospora_cyanea_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharomonospora_cyanea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharomonospora_cyanea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharomonospora_cyanea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["882082"]),
        None,
        Some("."),
        Some("SaccyDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharomonospora marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "882083.SacmaDRAFT_0001";
/// let this_library_node_name2 = "882083.SacmaDRAFT_5785";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharomonospora_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharomonospora_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharomonospora_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharomonospora_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["882083"]),
        None,
        Some("."),
        Some("SacmaDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharomonospora xinjiangensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "882086.SacxiDRAFT_0001";
/// let this_library_node_name2 = "882086.SacxiDRAFT_4421";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharomonospora_xinjiangensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharomonospora_xinjiangensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharomonospora_xinjiangensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharomonospora_xinjiangensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["882086"]),
        None,
        Some("."),
        Some("SacxiDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia rhizoxinica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "882378.RBRH_00002";
/// let this_library_node_name2 = "882378.RBRH_04315";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_rhizoxinica_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_rhizoxinica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_rhizoxinica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_rhizoxinica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["882378"]),
        None,
        Some("."),
        Some("RBRH_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobaculum massiliae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883066.HMPREF9233_00001";
/// let this_library_node_name2 = "883066.HMPREF9233_01697";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobaculum_massiliae_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobaculum_massiliae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobaculum_massiliae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobaculum_massiliae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883066"]),
        None,
        Some("."),
        Some("HMPREF9233_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobaculum schaalii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883067.HMPREF9237_00001";
/// let this_library_node_name2 = "883067.HMPREF9237_01781";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobaculum_schaalii_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobaculum_schaalii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobaculum_schaalii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobaculum_schaalii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883067"]),
        None,
        Some("."),
        Some("HMPREF9237_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces europaeus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883069.HMPREF9238_00001";
/// let this_library_node_name2 = "883069.HMPREF9238_01726";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_europaeus_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_europaeus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_europaeus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_europaeus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883069"]),
        None,
        Some("."),
        Some("HMPREF9238_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces turicensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883077.HMPREF9241_00001";
/// let this_library_node_name2 = "883077.HMPREF9241_01717";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_turicensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_turicensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_turicensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_turicensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883077"]),
        None,
        Some("."),
        Some("HMPREF9241_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Afipia broomeae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883078.HMPREF9695_00001";
/// let this_library_node_name2 = "883078.HMPREF9695_05042";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_afipia_broomeae_node_name(this_library_node_name1));
/// assert!(is_valid_string_afipia_broomeae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_afipia_broomeae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_afipia_broomeae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883078"]),
        None,
        Some("."),
        Some("HMPREF9695_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Afipia felis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883080.HMPREF9697_00001";
/// let this_library_node_name2 = "883080.HMPREF9697_04046";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_afipia_felis_node_name(this_library_node_name1));
/// assert!(is_valid_string_afipia_felis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_afipia_felis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_afipia_felis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883080"]),
        None,
        Some("."),
        Some("HMPREF9697_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alloiococcus otitis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883081.HMPREF9698_00001";
/// let this_library_node_name2 = "883081.HMPREF9698_01630";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alloiococcus_otitis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alloiococcus_otitis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alloiococcus_otitis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alloiococcus_otitis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883081"]),
        None,
        Some("."),
        Some("HMPREF9698_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bergeyella zoohelcum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883096.HMPREF9699_00001";
/// let this_library_node_name2 = "883096.HMPREF9699_02138";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bergeyella_zoohelcum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bergeyella_zoohelcum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bergeyella_zoohelcum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bergeyella_zoohelcum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883096"]),
        None,
        Some("."),
        Some("HMPREF9699_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dolosigranulum pigrum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883103.HMPREF9703_00001";
/// let this_library_node_name2 = "883103.HMPREF9703_01692";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dolosigranulum_pigrum_node_name(this_library_node_name1));
/// assert!(is_valid_string_dolosigranulum_pigrum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dolosigranulum_pigrum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dolosigranulum_pigrum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883103"]),
        None,
        Some("."),
        Some("HMPREF9703_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium infirmum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883109.HMPREF0380_00001";
/// let this_library_node_name2 = "883109.HMPREF0380_01765";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_infirmum_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_infirmum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_infirmum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_infirmum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883109"]),
        None,
        Some("."),
        Some("HMPREF0380_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Facklamia hominis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883110.HMPREF9260_00016";
/// let this_library_node_name2 = "883110.HMPREF9260_01820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_facklamia_hominis_node_name(this_library_node_name1));
/// assert!(is_valid_string_facklamia_hominis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_facklamia_hominis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_facklamia_hominis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883110"]),
        None,
        Some("."),
        Some("HMPREF9260_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Facklamia ignava nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883112.HMPREF9707_00001";
/// let this_library_node_name2 = "883112.HMPREF9707_01643";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_facklamia_ignava_node_name(this_library_node_name1));
/// assert!(is_valid_string_facklamia_ignava_node_name(this_library_node_name2));
/// assert!(!is_valid_string_facklamia_ignava_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_facklamia_ignava_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883112"]),
        None,
        Some("."),
        Some("HMPREF9707_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Facklamia languida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883113.HMPREF9708_00001";
/// let this_library_node_name2 = "883113.HMPREF9708_01528";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_facklamia_languida_node_name(this_library_node_name1));
/// assert!(is_valid_string_facklamia_languida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_facklamia_languida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_facklamia_languida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883113"]),
        None,
        Some("."),
        Some("HMPREF9708_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helcococcus kunzii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883114.HMPREF9709_00001";
/// let this_library_node_name2 = "883114.HMPREF9709_01882";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helcococcus_kunzii_node_name(this_library_node_name1));
/// assert!(is_valid_string_helcococcus_kunzii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helcococcus_kunzii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helcococcus_kunzii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883114"]),
        None,
        Some("."),
        Some("HMPREF9709_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Massilia timonae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883126.HMPREF9710_00001";
/// let this_library_node_name2 = "883126.HMPREF9710_05236";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_massilia_timonae_node_name(this_library_node_name1));
/// assert!(is_valid_string_massilia_timonae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_massilia_timonae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_massilia_timonae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883126"]),
        None,
        Some("."),
        Some("HMPREF9710_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Veillonella ratti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883156.HMPREF9282_00001";
/// let this_library_node_name2 = "883156.HMPREF9282_02126";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_veillonella_ratti_node_name(this_library_node_name1));
/// assert!(is_valid_string_veillonella_ratti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_veillonella_ratti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_veillonella_ratti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883156"]),
        None,
        Some("."),
        Some("HMPREF9282_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella micans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883158.HMPREF9140_00001";
/// let this_library_node_name2 = "883158.HMPREF9140_02064";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_micans_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_micans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_micans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_micans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883158"]),
        None,
        Some("."),
        Some("HMPREF9140_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus urinalis FB127CNA2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883168.HMPREF9318_00001";
/// let this_library_node_name2 = "883168.HMPREF9318_02203";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_urinalis_fb127cna2_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_urinalis_fb127cna2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_urinalis_fb127cna2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_urinalis_fb127cna2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883168"]),
        None,
        Some("."),
        Some("HMPREF9318_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Turicella otitidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "883169.HMPREF9719_00001";
/// let this_library_node_name2 = "883169.HMPREF9719_01846";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_turicella_otitidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_turicella_otitidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_turicella_otitidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_turicella_otitidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["883169"]),
        None,
        Some("."),
        Some("HMPREF9719_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Jonquetella anthropi DSM22815 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "885272.JonanDRAFT_0001";
/// let this_library_node_name2 = "885272.JonanDRAFT_1587";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_jonquetella_anthropi_dsm22815_node_name(this_library_node_name1));
/// assert!(is_valid_string_jonquetella_anthropi_dsm22815_node_name(this_library_node_name2));
/// assert!(!is_valid_string_jonquetella_anthropi_dsm22815_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_jonquetella_anthropi_dsm22815_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["885272"]),
        None,
        Some("."),
        Some("JonanDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fukomys damarensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "885580.XP_010601174.1";
/// let this_library_node_name2 = "885580.XP_010643983.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fukomys_damarensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_fukomys_damarensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fukomys_damarensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fukomys_damarensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["885580"]),
        None,
        Some("."),
        Some("XP_0106"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Singulisphaera acidiphila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "886293.Sinac_0001";
/// let this_library_node_name2 = "886293.Sinac_7598";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_singulisphaera_acidiphila_node_name(this_library_node_name1));
/// assert!(is_valid_string_singulisphaera_acidiphila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_singulisphaera_acidiphila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_singulisphaera_acidiphila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["886293"]),
        None,
        Some("."),
        Some("Sinac_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Muricauda ruestringensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "886377.Murru_0001";
/// let this_library_node_name2 = "886377.Murru_R0006";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_muricauda_ruestringensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_muricauda_ruestringensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_muricauda_ruestringensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_muricauda_ruestringensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["886377"]),
        None,
        Some("."),
        Some("Murru_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerophaga thermohalophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "886379.AEWI01000001_gene1637";
/// let this_library_node_name2 = "886379.AEWI01000211_gene2522";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerophaga_thermohalophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerophaga_thermohalophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerophaga_thermohalophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerophaga_thermohalophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["886379"]),
        None,
        Some("."),
        Some("AEWI01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus polymyxa SC2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "886882.PPSC2_c0001";
/// let this_library_node_name2 = "886882.PPSC2_p0632";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_polymyxa_sc2_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_polymyxa_sc2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_polymyxa_sc2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_polymyxa_sc2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["886882"]),
        None,
        Some("."),
        Some("PPSC2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hylemonella gracilis ATCC19624 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "887062.HGR_00005";
/// let this_library_node_name2 = "887062.HGR_16987";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hylemonella_gracilis_atcc19624_node_name(this_library_node_name1));
/// assert!(is_valid_string_hylemonella_gracilis_atcc19624_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hylemonella_gracilis_atcc19624_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hylemonella_gracilis_atcc19624_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["887062"]),
        None,
        Some("."),
        Some("HGR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnoanaerobaculum saburreum DSM3986 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "887325.HMPREF0381_0001";
/// let this_library_node_name2 = "887325.HMPREF0381_2955";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnoanaerobaculum_saburreum_dsm3986_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnoanaerobaculum_saburreum_dsm3986_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnoanaerobaculum_saburreum_dsm3986_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnoanaerobaculum_saburreum_dsm3986_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["887325"]),
        None,
        Some("."),
        Some("HMPREF0381_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kingella kingae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "887327.HMPREF0476_0001";
/// let this_library_node_name2 = "887327.HMPREF0476_2102";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kingella_kingae_node_name(this_library_node_name1));
/// assert!(is_valid_string_kingella_kingae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kingella_kingae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kingella_kingae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["887327"]),
        None,
        Some("."),
        Some("HMPREF0476_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lautropia mirabilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "887898.HMPREF0551_0001";
/// let this_library_node_name2 = "887898.HMPREF0551_2669";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lautropia_mirabilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lautropia_mirabilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lautropia_mirabilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lautropia_mirabilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["887898"]),
        None,
        Some("."),
        Some("HMPREF0551_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoramibacter alactolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "887929.HMP0721_0001";
/// let this_library_node_name2 = "887929.HMP0721_2519";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoramibacter_alactolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoramibacter_alactolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoramibacter_alactolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoramibacter_alactolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["887929"]),
        None,
        Some("."),
        Some("HMP0721_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus parasanguinis ATCC903 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888048.HMPREF8577_0001";
/// let this_library_node_name2 = "888048.HMPREF8577_2080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_parasanguinis_atcc903_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_parasanguinis_atcc903_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_parasanguinis_atcc903_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_parasanguinis_atcc903_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888048"]),
        None,
        Some("."),
        Some("HMPREF8577_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus oralis ATCC49296 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888049.HMPREF8578_0001";
/// let this_library_node_name2 = "888049.HMPREF8578_2013";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_oralis_atcc49296_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_oralis_atcc49296_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_oralis_atcc49296_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_oralis_atcc49296_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888049"]),
        None,
        Some("."),
        Some("HMPREF8578_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces cardiffensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888050.HMPREF9004_0001";
/// let this_library_node_name2 = "888050.HMPREF9004_1983";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_cardiffensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_cardiffensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_cardiffensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_cardiffensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888050"]),
        None,
        Some("."),
        Some("HMPREF9004_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. F0310 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888052.HMPREF9006_0001";
/// let this_library_node_name2 = "888052.HMPREF9006_2070";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_f0310_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_f0310_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_f0310_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_f0310_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888052"]),
        None,
        Some("."),
        Some("HMPREF9006_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptotrichia wadei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888055.HMPREF9015_00001";
/// let this_library_node_name2 = "888055.HMPREF9015_02313";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptotrichia_wadei_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptotrichia_wadei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptotrichia_wadei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptotrichia_wadei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888055"]),
        None,
        Some("."),
        Some("HMPREF9015_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. F0400 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888056.HMPREF9062_0001";
/// let this_library_node_name2 = "888056.HMPREF9062_2518";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_f0400_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_f0400_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_f0400_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_f0400_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888056"]),
        None,
        Some("."),
        Some("HMPREF9062_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga sp. F0234 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888059.HMPREF9071_0001";
/// let this_library_node_name2 = "888059.HMPREF9071_2445";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_sp_f0234_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_sp_f0234_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_sp_f0234_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_sp_f0234_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888059"]),
        None,
        Some("."),
        Some("HMPREF9071_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Centipeda periodontii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888060.HMPREF9081_0001";
/// let this_library_node_name2 = "888060.HMPREF9081_2633";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_centipeda_periodontii_node_name(this_library_node_name1));
/// assert!(is_valid_string_centipeda_periodontii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_centipeda_periodontii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_centipeda_periodontii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888060"]),
        None,
        Some("."),
        Some("HMPREF9081_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dialister micraerophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888062.HMPREF9083_0001";
/// let this_library_node_name2 = "888062.HMPREF9083_1244";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dialister_micraerophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_dialister_micraerophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dialister_micraerophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dialister_micraerophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888062"]),
        None,
        Some("."),
        Some("HMPREF9083_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus italicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888064.HMPREF9088_0001";
/// let this_library_node_name2 = "888064.HMPREF9088_2405";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_italicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_italicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_italicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_italicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888064"]),
        None,
        Some("."),
        Some("HMPREF9088_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces neuii BVS029A5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888439.HMPREF9240_00001";
/// let this_library_node_name2 = "888439.HMPREF9240_01935";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_neuii_bvs029a5_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_neuii_bvs029a5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_neuii_bvs029a5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_neuii_bvs029a5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888439"]),
        None,
        Some("."),
        Some("HMPREF9240_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium sulci nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888727.HMPREF9092_0001";
/// let this_library_node_name2 = "888727.HMPREF9092_1651";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_sulci_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_sulci_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_sulci_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_sulci_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888727"]),
        None,
        Some("."),
        Some("HMPREF9092_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella multiformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888743.HMPREF9141_0001";
/// let this_library_node_name2 = "888743.HMPREF9141_2887";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_multiformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_multiformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_multiformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_multiformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888743"]),
        None,
        Some("."),
        Some("HMPREF9141_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus peroris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888746.HMPREF9180_0001";
/// let this_library_node_name2 = "888746.HMPREF9180_1638";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_peroris_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_peroris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_peroris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_peroris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888746"]),
        None,
        Some("."),
        Some("HMPREF9180_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sanguinis SK49 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888808.HMPREF9380_0001";
/// let this_library_node_name2 = "888808.HMPREF9380_2274";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sanguinis_sk49_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sanguinis_sk49_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sanguinis_sk49_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sanguinis_sk49_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888808"]),
        None,
        Some("."),
        Some("HMPREF9380_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sanguinis SK355 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888816.HMPREF9389_0001";
/// let this_library_node_name2 = "888816.HMPREF9389_2320";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sanguinis_sk355_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sanguinis_sk355_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sanguinis_sk355_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sanguinis_sk355_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888816"]),
        None,
        Some("."),
        Some("HMPREF9389_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sanguinis SK1057 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888821.HMPREF9394_0001";
/// let this_library_node_name2 = "888821.HMPREF9394_2323";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sanguinis_sk1057_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sanguinis_sk1057_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sanguinis_sk1057_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sanguinis_sk1057_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888821"]),
        None,
        Some("."),
        Some("HMPREF9394_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella salivae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888832.HMPREF9420_0001";
/// let this_library_node_name2 = "888832.HMPREF9420_2940";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_salivae_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_salivae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_salivae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_salivae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888832"]),
        None,
        Some("."),
        Some("HMPREF9420_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus australis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "888833.HMPREF9421_0001";
/// let this_library_node_name2 = "888833.HMPREF9421_2031";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_australis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_australis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_australis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_australis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["888833"]),
        None,
        Some("."),
        Some("HMPREF9421_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus cristatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "889201.HMPREF9422_0001";
/// let this_library_node_name2 = "889201.HMPREF9422_1967";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_cristatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_cristatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_cristatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_cristatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["889201"]),
        None,
        Some("."),
        Some("HMPREF9422_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus infantis ATCC700779 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "889204.HMPREF9423_0001";
/// let this_library_node_name2 = "889204.HMPREF9423_1928";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_infantis_atcc700779_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_infantis_atcc700779_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_infantis_atcc700779_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_infantis_atcc700779_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["889204"]),
        None,
        Some("."),
        Some("HMPREF9423_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirochaeta africana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "889378.Spiaf_0001";
/// let this_library_node_name2 = "889378.Spiaf_2874";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirochaeta_africana_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirochaeta_africana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirochaeta_africana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirochaeta_africana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["889378"]),
        None,
        Some("."),
        Some("Spiaf_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus acidophilus 30SC nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "891391.LAC30SC_00005";
/// let this_library_node_name2 = "891391.LAC30SC_10955";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_acidophilus_30sc_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_acidophilus_30sc_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_acidophilus_30sc_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_acidophilus_30sc_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["891391"]),
        None,
        Some("."),
        Some("LAC30SC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerobaculum mobile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "891968.Anamo_0001";
/// let this_library_node_name2 = "891968.Anamo_2109";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerobaculum_mobile_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerobaculum_mobile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerobaculum_mobile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerobaculum_mobile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["891968"]),
        None,
        Some("."),
        Some("Anamo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Plautia stali nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "891974.E05_00010";
/// let this_library_node_name2 = "891974.E05_51480";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_plautia_stali_node_name(this_library_node_name1));
/// assert!(is_valid_string_plautia_stali_node_name(this_library_node_name2));
/// assert!(!is_valid_string_plautia_stali_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_plautia_stali_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["891974"]),
        None,
        Some("."),
        Some("E05_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moranella endobia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "903503.MEPCIT_001";
/// let this_library_node_name2 = "903503.MEPCIT_462";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moranella_endobia_node_name(this_library_node_name1));
/// assert!(is_valid_string_moranella_endobia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moranella_endobia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moranella_endobia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["903503"]),
        None,
        Some("."),
        Some("MEPCIT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium limosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "903814.ELI_0001";
/// let this_library_node_name2 = "903814.ELI_4672";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_limosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_limosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_limosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_limosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["903814"]),
        None,
        Some("."),
        Some("ELI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Holophaga foetida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "903818.KI912268_gene1000";
/// let this_library_node_name2 = "903818.KI912269_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_holophaga_foetida_node_name(this_library_node_name1));
/// assert!(is_valid_string_holophaga_foetida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_holophaga_foetida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_holophaga_foetida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["903818"]),
        None,
        Some("."),
        Some("KI91226"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gardnerella vaginalis 101 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "904144.AEJD01000001_gene2";
/// let this_library_node_name2 = "904144.AEJD01000033_gene982";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gardnerella_vaginalis_101_node_name(this_library_node_name1));
/// assert!(is_valid_string_gardnerella_vaginalis_101_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gardnerella_vaginalis_101_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gardnerella_vaginalis_101_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["904144"]),
        None,
        Some("."),
        Some("AEJD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus downei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "904293.HMPREF9176_0001";
/// let this_library_node_name2 = "904293.HMPREF9176_2297";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_downei_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_downei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_downei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_downei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["904293"]),
        None,
        Some("."),
        Some("HMPREF9176_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. F0418 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "904294.HMPREF9182_0001";
/// let this_library_node_name2 = "904294.HMPREF9182_2056";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_f0418_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_f0418_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_f0418_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_f0418_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["904294"]),
        None,
        Some("."),
        Some("HMPREF9182_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oribacterium sp. F0425 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "904296.HMPREF9124_0004";
/// let this_library_node_name2 = "904296.HMPREF9124_2408";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oribacterium_sp_f0425_node_name(this_library_node_name1));
/// assert!(is_valid_string_oribacterium_sp_f0425_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oribacterium_sp_f0425_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oribacterium_sp_f0425_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["904296"]),
        None,
        Some("."),
        Some("HMPREF9124_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus vestibularis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "904306.HMPREF9192_0001";
/// let this_library_node_name2 = "904306.HMPREF9192_2076";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_vestibularis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_vestibularis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_vestibularis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_vestibularis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["904306"]),
        None,
        Some("."),
        Some("HMPREF9192_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus pettenkoferi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "904314.SEVCU012_0001";
/// let this_library_node_name2 = "904314.SEVCU012_2439";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_pettenkoferi_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_pettenkoferi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_pettenkoferi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_pettenkoferi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["904314"]),
        None,
        Some("."),
        Some("SEVCU012_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nonlabens ulvanivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "906888.JCM19314_1";
/// let this_library_node_name2 = "906888.JCM19314_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nonlabens_ulvanivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_nonlabens_ulvanivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nonlabens_ulvanivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nonlabens_ulvanivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["906888"]),
        None,
        Some("."),
        Some("JCM19314_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema brennaborense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "906968.Trebr_0001";
/// let this_library_node_name2 = "906968.Trebr_R0022";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_brennaborense_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_brennaborense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_brennaborense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_brennaborense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["906968"]),
        None,
        Some("."),
        Some("Trebr_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter pylori SouthAfrica7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "907239.HPSA_00005";
/// let this_library_node_name2 = "907239.HPSA_08160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_pylori_southafrica7_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_pylori_southafrica7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_pylori_southafrica7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_pylori_southafrica7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["907239"]),
        None,
        Some("."),
        Some("HPSA_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema saccharophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "907348.TresaDRAFT_0001";
/// let this_library_node_name2 = "907348.TresaDRAFT_2839";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_saccharophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_saccharophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_saccharophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_saccharophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["907348"]),
        None,
        Some("."),
        Some("TresaDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leuconostoc fallax nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "907931.AEIZ01000001_gene399";
/// let this_library_node_name2 = "907931.AEIZ01000030_gene1531";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leuconostoc_fallax_node_name(this_library_node_name1));
/// assert!(is_valid_string_leuconostoc_fallax_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leuconostoc_fallax_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leuconostoc_fallax_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["907931"]),
        None,
        Some("."),
        Some("AEIZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eremococcus coleocola ACS139VCol8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "908337.HMPREF9257_0001";
/// let this_library_node_name2 = "908337.HMPREF9257_1796";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eremococcus_coleocola_acs139vcol8_node_name(this_library_node_name1));
/// assert!(is_valid_string_eremococcus_coleocola_acs139vcol8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eremococcus_coleocola_acs139vcol8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eremococcus_coleocola_acs139vcol8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["908337"]),
        None,
        Some("."),
        Some("HMPREF9257_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus harei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "908338.HMPREF9286_0001";
/// let this_library_node_name2 = "908338.HMPREF9286_1790";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_harei_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_harei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_harei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_harei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["908338"]),
        None,
        Some("."),
        Some("HMPREF9286_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus oris PB013T23 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "908339.HMPREF9265_0001";
/// let this_library_node_name2 = "908339.HMPREF9265_2112";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_oris_pb013t23_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_oris_pb013t23_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_oris_pb013t23_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_oris_pb013t23_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["908339"]),
        None,
        Some("."),
        Some("HMPREF9265_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. HGF2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "908340.HMPREF9406_0001";
/// let this_library_node_name2 = "908340.HMPREF9406_4300";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_hgf2_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_hgf2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_hgf2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_hgf2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["908340"]),
        None,
        Some("."),
        Some("HMPREF9406_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alistipes sp. HGB5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "908612.HMPREF9720_0001";
/// let this_library_node_name2 = "908612.HMPREF9720_3054";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alistipes_sp_hgb5_node_name(this_library_node_name1));
/// assert!(is_valid_string_alistipes_sp_hgb5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alistipes_sp_hgb5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alistipes_sp_hgb5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["908612"]),
        None,
        Some("."),
        Some("HMPREF9720_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella dentalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "908937.Prede_0001";
/// let this_library_node_name2 = "908937.Prede_2715";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_dentalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_dentalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_dentalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_dentalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["908937"]),
        None,
        Some("."),
        Some("Prede_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinokineospora sp. EG49 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "909613.UO65_0001";
/// let this_library_node_name2 = "909613.UO65_6682";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinokineospora_sp_eg49_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinokineospora_sp_eg49_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinokineospora_sp_eg49_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinokineospora_sp_eg49_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["909613"]),
        None,
        Some("."),
        Some("UO65_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Syntrophorhabdus aromaticivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "909663.KI867149_gene3168";
/// let this_library_node_name2 = "909663.KI867151_gene3167";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_syntrophorhabdus_aromaticivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_syntrophorhabdus_aromaticivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_syntrophorhabdus_aromaticivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_syntrophorhabdus_aromaticivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["909663"]),
        None,
        Some("."),
        Some("KI8671"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alphaproteobacterium SAR116 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "909943.HIMB100_00000010";
/// let this_library_node_name2 = "909943.HIMB100_00023760";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alphaproteobacterium_sar116_node_name(this_library_node_name1));
/// assert!(is_valid_string_alphaproteobacterium_sar116_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alphaproteobacterium_sar116_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alphaproteobacterium_sar116_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["909943"]),
        None,
        Some("."),
        Some("HIMB100_000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus pseudoporcinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "910313.HMPREF9320_0001";
/// let this_library_node_name2 = "910313.HMPREF9320_2089";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_pseudoporcinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_pseudoporcinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_pseudoporcinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_pseudoporcinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["910313"]),
        None,
        Some("."),
        Some("HMPREF9320_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dialister microaerophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "910314.HMPREF9220_0001";
/// let this_library_node_name2 = "910314.HMPREF9220_1383";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dialister_microaerophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_dialister_microaerophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dialister_microaerophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dialister_microaerophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["910314"]),
        None,
        Some("."),
        Some("HMPREF9220_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ewingella americana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "910964.GEAM_0001";
/// let this_library_node_name2 = "910964.GEAM_4468";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ewingella_americana_node_name(this_library_node_name1));
/// assert!(is_valid_string_ewingella_americana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ewingella_americana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ewingella_americana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["910964"]),
        None,
        Some("."),
        Some("GEAM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leclercia adecarboxylata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "911008.GLAD_00001";
/// let this_library_node_name2 = "911008.GLAD_04718";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leclercia_adecarboxylata_node_name(this_library_node_name1));
/// assert!(is_valid_string_leclercia_adecarboxylata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leclercia_adecarboxylata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leclercia_adecarboxylata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["911008"]),
        None,
        Some("."),
        Some("GLAD_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudovibrio sp. FOBEG1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "911045.PSE_0001";
/// let this_library_node_name2 = "911045.PSE_p0398";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudovibrio_sp_fobeg1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudovibrio_sp_fobeg1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudovibrio_sp_fobeg1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudovibrio_sp_fobeg1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["911045"]),
        None,
        Some("."),
        Some("PSE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Weissella cibaria nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "911104.AEKT01000001_gene10";
/// let this_library_node_name2 = "911104.AEKT01000072_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_weissella_cibaria_node_name(this_library_node_name1));
/// assert!(is_valid_string_weissella_cibaria_node_name(this_library_node_name2));
/// assert!(!is_valid_string_weissella_cibaria_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_weissella_cibaria_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["911104"]),
        None,
        Some("."),
        Some("AEKT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. CF149 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "911239.CF149_00005";
/// let this_library_node_name2 = "911239.CF149_23878";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_cf149_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_cf149_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_cf149_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_cf149_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["911239"]),
        None,
        Some("."),
        Some("CF149_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysobacter arseniciresistens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "913325.N799_00005";
/// let this_library_node_name2 = "913325.N799_14420";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysobacter_arseniciresistens_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysobacter_arseniciresistens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysobacter_arseniciresistens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysobacter_arseniciresistens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["913325"]),
        None,
        Some("."),
        Some("N799_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus coryniformis KCTC3167 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "913848.AELK01000001_gene19";
/// let this_library_node_name2 = "913848.AELK01000268_gene1755";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_coryniformis_kctc3167_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_coryniformis_kctc3167_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_coryniformis_kctc3167_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_coryniformis_kctc3167_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["913848"]),
        None,
        Some("."),
        Some("AELK01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfosporosinus sp. OT nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "913865.DOT_0001";
/// let this_library_node_name2 = "913865.DOT_6299";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfosporosinus_sp_ot_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfosporosinus_sp_ot_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfosporosinus_sp_ot_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfosporosinus_sp_ot_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["913865"]),
        None,
        Some("."),
        Some("DOT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sediminibacterium sp. OR53 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "925409.KI911562_gene1";
/// let this_library_node_name2 = "925409.KI911562_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sediminibacterium_sp_or53_node_name(this_library_node_name1));
/// assert!(is_valid_string_sediminibacterium_sp_or53_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sediminibacterium_sp_or53_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sediminibacterium_sp_or53_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["925409"]),
        None,
        Some("."),
        Some("KI911562_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas vesicatoria nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "925775.XVE_0001";
/// let this_library_node_name2 = "925775.XVE_5107";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_vesicatoria_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_vesicatoria_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_vesicatoria_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_vesicatoria_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["925775"]),
        None,
        Some("."),
        Some("XVE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Adhaeribacter aquaticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926549.KI421517_gene1";
/// let this_library_node_name2 = "926549.KI421517_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_adhaeribacter_aquaticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_adhaeribacter_aquaticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_adhaeribacter_aquaticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_adhaeribacter_aquaticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926549"]),
        None,
        Some("."),
        Some("KI421517_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldilinea aerophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926550.CLDAP_00010";
/// let this_library_node_name2 = "926550.CLDAP_41190";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldilinea_aerophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldilinea_aerophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldilinea_aerophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldilinea_aerophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926550"]),
        None,
        Some("."),
        Some("CLDAP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga cynodegmi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926551.KB900703_gene1000";
/// let this_library_node_name2 = "926551.KB900739_gene97";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_cynodegmi_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_cynodegmi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_cynodegmi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_cynodegmi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926551"]),
        None,
        Some("."),
        Some("KB9007"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus pimensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926554.KI912614_gene4849";
/// let this_library_node_name2 = "926554.KI912680_gene867";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_pimensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_pimensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_pimensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_pimensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926554"]),
        None,
        Some("."),
        Some("KI9126"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Echinicola vietnamensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926556.Echvi_0001";
/// let this_library_node_name2 = "926556.Echvi_4684";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_echinicola_vietnamensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_echinicola_vietnamensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_echinicola_vietnamensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_echinicola_vietnamensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926556"]),
        None,
        Some("."),
        Some("Echvi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Joostella marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926559.JoomaDRAFT_0002";
/// let this_library_node_name2 = "926559.JoomaDRAFT_4006";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_joostella_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_joostella_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_joostella_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_joostella_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926559"]),
        None,
        Some("."),
        Some("JoomaDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Meiothermus chliarophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926560.KE387023_gene1107";
/// let this_library_node_name2 = "926560.KE387029_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_meiothermus_chliarophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_meiothermus_chliarophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_meiothermus_chliarophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_meiothermus_chliarophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926560"]),
        None,
        Some("."),
        Some("KE38702"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Orenia marismortui nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926561.KB900617_gene1195";
/// let this_library_node_name2 = "926561.KB900625_gene2345";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_orenia_marismortui_node_name(this_library_node_name1));
/// assert!(is_valid_string_orenia_marismortui_node_name(this_library_node_name2));
/// assert!(!is_valid_string_orenia_marismortui_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_orenia_marismortui_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926561"]),
        None,
        Some("."),
        Some("KB9006"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Owenweeksia hongkongensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926562.Oweho_0001";
/// let this_library_node_name2 = "926562.Oweho_3564";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_owenweeksia_hongkongensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_owenweeksia_hongkongensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_owenweeksia_hongkongensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_owenweeksia_hongkongensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926562"]),
        None,
        Some("."),
        Some("Oweho_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Promicromonospora kroppenstedtii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926564.KI911564_gene5928";
/// let this_library_node_name2 = "926564.KI911770_gene1855";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_promicromonospora_kroppenstedtii_node_name(this_library_node_name1));
/// assert!(is_valid_string_promicromonospora_kroppenstedtii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_promicromonospora_kroppenstedtii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_promicromonospora_kroppenstedtii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926564"]),
        None,
        Some("."),
        Some("KI911"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Terriglobus roseus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926566.Terro_0001";
/// let this_library_node_name2 = "926566.Terro_4401";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_terriglobus_roseus_node_name(this_library_node_name1));
/// assert!(is_valid_string_terriglobus_roseus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_terriglobus_roseus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_terriglobus_roseus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926566"]),
        None,
        Some("."),
        Some("Terro_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermanaerovibrio velox nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926567.TheveDRAFT_0001";
/// let this_library_node_name2 = "926567.TheveDRAFT_1810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermanaerovibrio_velox_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermanaerovibrio_velox_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermanaerovibrio_velox_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermanaerovibrio_velox_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926567"]),
        None,
        Some("."),
        Some("TheveDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerolinea thermophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926569.ANT_00010";
/// let this_library_node_name2 = "926569.ANT_31770";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerolinea_thermophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerolinea_thermophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerolinea_thermophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerolinea_thermophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926569"]),
        None,
        Some("."),
        Some("ANT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloplanus natans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926690.KE386573_gene100";
/// let this_library_node_name2 = "926690.KE386574_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloplanus_natans_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloplanus_natans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloplanus_natans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloplanus_natans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926690"]),
        None,
        Some("."),
        Some("KE38657"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halonatronum saccharophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "926692.AZYG01000001_gene646";
/// let this_library_node_name2 = "926692.AZYG01000099_gene2368";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halonatronum_saccharophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_halonatronum_saccharophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halonatronum_saccharophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halonatronum_saccharophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["926692"]),
        None,
        Some("."),
        Some("AZYG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alkaliflexus imshenetskii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "927658.AJUM01000001_gene2474";
/// let this_library_node_name2 = "927658.AJUM01000047_gene3036";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alkaliflexus_imshenetskii_node_name(this_library_node_name1));
/// assert!(is_valid_string_alkaliflexus_imshenetskii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alkaliflexus_imshenetskii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alkaliflexus_imshenetskii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["927658"]),
        None,
        Some("."),
        Some("AJUM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus oralis Uo5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "927666.SOR_0001";
/// let this_library_node_name2 = "927666.SOR_1991";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_oralis_uo5_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_oralis_uo5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_oralis_uo5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_oralis_uo5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["927666"]),
        None,
        Some("."),
        Some("SOR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechocystis sp. PCC7509 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "927677.ALVU02000001_gene1000";
/// let this_library_node_name2 = "927677.ALVU02000008_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechocystis_sp_pcc7509_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechocystis_sp_pcc7509_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechocystis_sp_pcc7509_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechocystis_sp_pcc7509_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["927677"]),
        None,
        Some("."),
        Some("ALVU0200000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leuconostoc gelidum KCTC3527 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "927691.AEMI01000001_gene1314";
/// let this_library_node_name2 = "927691.AEMI01000043_gene1253";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leuconostoc_gelidum_kctc3527_node_name(this_library_node_name1));
/// assert!(is_valid_string_leuconostoc_gelidum_kctc3527_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leuconostoc_gelidum_kctc3527_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leuconostoc_gelidum_kctc3527_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["927691"]),
        None,
        Some("."),
        Some("AEMI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas ruminantium lactilytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "927704.SELR_00010";
/// let this_library_node_name2 = "927704.SELR_28260";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_ruminantium_lactilytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_ruminantium_lactilytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_ruminantium_lactilytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_ruminantium_lactilytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["927704"]),
        None,
        Some("."),
        Some("SELR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella sp. R4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "928210.CALU01000001_gene463";
/// let this_library_node_name2 = "928210.CALU01000144_gene1558";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_sp_r4_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_sp_r4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_sp_r4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_sp_r4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["928210"]),
        None,
        Some("."),
        Some("CALU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharomonospora glauca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "928724.SacglDRAFT_00002";
/// let this_library_node_name2 = "928724.SacglDRAFT_04388";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharomonospora_glauca_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharomonospora_glauca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharomonospora_glauca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharomonospora_glauca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["928724"]),
        None,
        Some("."),
        Some("SacglDRAFT_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium botulinum BKT015925 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "929506.CbC4_0001";
/// let this_library_node_name2 = "929506.CbC4_8013";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_botulinum_bkt015925_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_botulinum_bkt015925_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_botulinum_bkt015925_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_botulinum_bkt015925_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["929506"]),
        None,
        Some("."),
        Some("CbC4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solitalea canadensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "929556.Solca_0001";
/// let this_library_node_name2 = "929556.Solca_4490";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solitalea_canadensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_solitalea_canadensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solitalea_canadensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solitalea_canadensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["929556"]),
        None,
        Some("."),
        Some("Solca_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurimonas gotlandica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "929558.SMGD1_0001";
/// let this_library_node_name2 = "929558.SMGD1_2879";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurimonas_gotlandica_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurimonas_gotlandica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurimonas_gotlandica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurimonas_gotlandica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["929558"]),
        None,
        Some("."),
        Some("SMGD1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Emticicia oligotrophica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "929562.Emtol_0337";
/// let this_library_node_name2 = "929562.Emtol_R0042";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_emticicia_oligotrophica_node_name(this_library_node_name1));
/// assert!(is_valid_string_emticicia_oligotrophica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_emticicia_oligotrophica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_emticicia_oligotrophica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["929562"]),
        None,
        Some("."),
        Some("Emtol_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flectobacillus major nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "929703.KE386491_gene1";
/// let this_library_node_name2 = "929703.KE386492_gene4458";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flectobacillus_major_node_name(this_library_node_name1));
/// assert!(is_valid_string_flectobacillus_major_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flectobacillus_major_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flectobacillus_major_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["929703"]),
        None,
        Some("."),
        Some("KE38649"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myroides odoratus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "929704.Myrod_0001";
/// let this_library_node_name2 = "929704.Myrod_3808";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myroides_odoratus_node_name(this_library_node_name1));
/// assert!(is_valid_string_myroides_odoratus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myroides_odoratus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myroides_odoratus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["929704"]),
        None,
        Some("."),
        Some("Myrod_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Patulibacter minatonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "929712.KI912613_gene1";
/// let this_library_node_name2 = "929712.KI912613_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_patulibacter_minatonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_patulibacter_minatonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_patulibacter_minatonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_patulibacter_minatonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["929712"]),
        None,
        Some("."),
        Some("KI912613_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Niabella soli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "929713.NIASO_00005";
/// let this_library_node_name2 = "929713.NIASO_21035";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_niabella_soli_node_name(this_library_node_name1));
/// assert!(is_valid_string_niabella_soli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_niabella_soli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_niabella_soli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["929713"]),
        None,
        Some("."),
        Some("NIASO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella senegalensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "929794.CALV01000001_gene1578";
/// let this_library_node_name2 = "929794.CALV01000099_gene1436";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_senegalensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_senegalensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_senegalensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_senegalensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["929794"]),
        None,
        Some("."),
        Some("CALV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas brassicacearum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "930166.CD58_00005";
/// let this_library_node_name2 = "930166.CD58_29830";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_brassicacearum_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_brassicacearum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_brassicacearum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_brassicacearum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["930166"]),
        None,
        Some("."),
        Some("CD58_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alcanivorax dieselolei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "930169.B5T_00001";
/// let this_library_node_name2 = "930169.B5T_04448";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alcanivorax_dieselolei_node_name(this_library_node_name1));
/// assert!(is_valid_string_alcanivorax_dieselolei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alcanivorax_dieselolei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alcanivorax_dieselolei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["930169"]),
        None,
        Some("."),
        Some("B5T_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter phenanthrenivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "930171.Asphe3_00010";
/// let this_library_node_name2 = "930171.Asphe3_41890";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_phenanthrenivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_phenanthrenivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_phenanthrenivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_phenanthrenivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["930171"]),
        None,
        Some("."),
        Some("Asphe3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfolobus islandicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "930945.SiRe_0001";
/// let this_library_node_name2 = "930945.SiRe_2695";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfolobus_islandicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfolobus_islandicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfolobus_islandicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfolobus_islandicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["930945"]),
        None,
        Some("."),
        Some("SiRe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fructobacillus fructosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "930946.AEOP01000001_gene567";
/// let this_library_node_name2 = "930946.AEOP01000057_gene676";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fructobacillus_fructosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_fructobacillus_fructosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fructobacillus_fructosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fructobacillus_fructosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["930946"]),
        None,
        Some("."),
        Some("AEOP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium saccharoperbutylacetonicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "931276.Cspa_c00010";
/// let this_library_node_name2 = "931276.Cspa_c58420";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_saccharoperbutylacetonicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_saccharoperbutylacetonicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_saccharoperbutylacetonicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_saccharoperbutylacetonicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["931276"]),
        None,
        Some("."),
        Some("Cspa_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halococcus morrhuae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "931277.C448_00005";
/// let this_library_node_name2 = "931277.C448_15508";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halococcus_morrhuae_node_name(this_library_node_name1));
/// assert!(is_valid_string_halococcus_morrhuae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halococcus_morrhuae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halococcus_morrhuae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["931277"]),
        None,
        Some("."),
        Some("C448_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetobacterium woodii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "931626.Awo_c00010";
/// let this_library_node_name2 = "931626.Awo_c35630";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetobacterium_woodii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetobacterium_woodii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetobacterium_woodii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetobacterium_woodii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["931626"]),
        None,
        Some("."),
        Some("Awo_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium rhodesiae JS60 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "931627.MycrhDRAFT_0001";
/// let this_library_node_name2 = "931627.MycrhDRAFT_7025";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_rhodesiae_js60_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_rhodesiae_js60_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_rhodesiae_js60_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_rhodesiae_js60_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["931627"]),
        None,
        Some("."),
        Some("MycrhDRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia sp. M24T3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "932213.SPM24T3_00005";
/// let this_library_node_name2 = "932213.SPM24T3_24345";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_sp_m24t3_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_sp_m24t3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_sp_m24t3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_sp_m24t3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["932213"]),
        None,
        Some("."),
        Some("SPM24T3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea ananatis AJ13355 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "932677.PAJ_0001";
/// let this_library_node_name2 = "932677.PAJ_p0280";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_ananatis_aj13355_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_ananatis_aj13355_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_ananatis_aj13355_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_ananatis_aj13355_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["932677"]),
        None,
        Some("."),
        Some("PAJ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermocrinis ruber nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "932678.THERU_00005";
/// let this_library_node_name2 = "932678.THERU_08500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermocrinis_ruber_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermocrinis_ruber_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermocrinis_ruber_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermocrinis_ruber_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["932678"]),
        None,
        Some("."),
        Some("THERU_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Planococcus donghaensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "933115.GPDM_00005";
/// let this_library_node_name2 = "933115.GPDM_16626";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_planococcus_donghaensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_planococcus_donghaensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_planococcus_donghaensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_planococcus_donghaensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["933115"]),
        None,
        Some("."),
        Some("GPDM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfosarcina sp. BuS5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "933262.AXAM01000001_gene325";
/// let this_library_node_name2 = "933262.AXAM01000222_gene924";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfosarcina_sp_bus5_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfosarcina_sp_bus5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfosarcina_sp_bus5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfosarcina_sp_bus5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["933262"]),
        None,
        Some("."),
        Some("AXAM01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidianus hospitalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "933801.Ahos_0001";
/// let this_library_node_name2 = "933801.Ahos_2353";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidianus_hospitalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidianus_hospitalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidianus_hospitalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidianus_hospitalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["933801"]),
        None,
        Some("."),
        Some("Ahos_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aminobacter sp. J41 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935261.JAGL01000001_gene1522";
/// let this_library_node_name2 = "935261.JAGL01000113_gene2920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aminobacter_sp_j41_node_name(this_library_node_name1));
/// assert!(is_valid_string_aminobacter_sp_j41_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aminobacter_sp_j41_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aminobacter_sp_j41_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935261"]),
        None,
        Some("."),
        Some("JAGL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium loti R88b nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935548.KI912159_gene1";
/// let this_library_node_name2 = "935548.KI912159_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_loti_r88b_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_loti_r88b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_loti_r88b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_loti_r88b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935548"]),
        None,
        Some("."),
        Some("KI912159_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sinorhizobium arboris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935557.ATYB01000001_gene5994";
/// let this_library_node_name2 = "935557.ATYB01000014_gene4638";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sinorhizobium_arboris_node_name(this_library_node_name1));
/// assert!(is_valid_string_sinorhizobium_arboris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sinorhizobium_arboris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sinorhizobium_arboris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935557"]),
        None,
        Some("."),
        Some("ATYB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus pantotrophus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935565.JAEM01000001_gene286";
/// let this_library_node_name2 = "935565.JAEM01000105_gene949";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_pantotrophus_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_pantotrophus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_pantotrophus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_pantotrophus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935565"]),
        None,
        Some("."),
        Some("JAEM01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoxanthomonas suwonensis J43 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935567.JAES01000001_gene2050";
/// let this_library_node_name2 = "935567.JAES01000065_gene2346";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoxanthomonas_suwonensis_j43_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoxanthomonas_suwonensis_j43_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoxanthomonas_suwonensis_j43_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoxanthomonas_suwonensis_j43_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935567"]),
        None,
        Some("."),
        Some("JAES010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. J33 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935836.JAEL01000001_gene657";
/// let this_library_node_name2 = "935836.JAEL01000201_gene4586";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_j33_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_j33_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_j33_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_j33_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935836"]),
        None,
        Some("."),
        Some("JAEL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. J37 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935837.JAEK01000001_gene2051";
/// let this_library_node_name2 = "935837.JAEK01000097_gene4151";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_j37_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_j37_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_j37_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_j37_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935837"]),
        None,
        Some("."),
        Some("JAEK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellulosimicrobium cellulans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935839.JAGJ01000001_gene1000";
/// let this_library_node_name2 = "935839.JAGJ01000050_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellulosimicrobium_cellulans_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellulosimicrobium_cellulans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellulosimicrobium_cellulans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellulosimicrobium_cellulans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935839"]),
        None,
        Some("."),
        Some("JAGJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chelativorans sp. J32 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935840.JAEQ01000001_gene2621";
/// let this_library_node_name2 = "935840.JAEQ01000048_gene1444";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chelativorans_sp_j32_node_name(this_library_node_name1));
/// assert!(is_valid_string_chelativorans_sp_j32_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chelativorans_sp_j32_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chelativorans_sp_j32_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935840"]),
        None,
        Some("."),
        Some("JAEQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. J14 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935845.JADQ01000001_gene1048";
/// let this_library_node_name2 = "935845.JADQ01000113_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_j14_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_j14_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_j14_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_j14_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935845"]),
        None,
        Some("."),
        Some("JADQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus sp. J39 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935848.JAEN01000001_gene3254";
/// let this_library_node_name2 = "935848.JAEN01000048_gene2689";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_sp_j39_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_sp_j39_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_sp_j39_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_sp_j39_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935848"]),
        None,
        Some("."),
        Some("JAEN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Luteimonas sp. J29 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935863.AWZR01000001_gene1546";
/// let this_library_node_name2 = "935863.AWZR01000018_gene121";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_luteimonas_sp_j29_node_name(this_library_node_name1));
/// assert!(is_valid_string_luteimonas_sp_j29_node_name(this_library_node_name2));
/// assert!(!is_valid_string_luteimonas_sp_j29_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_luteimonas_sp_j29_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935863"]),
        None,
        Some("."),
        Some("AWZR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardioides sp. J54 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935866.JAER01000001_gene2478";
/// let this_library_node_name2 = "935866.JAER01000081_gene3681";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardioides_sp_j54_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardioides_sp_j54_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardioides_sp_j54_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardioides_sp_j54_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935866"]),
        None,
        Some("."),
        Some("JAER010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldanaerobius polysaccharolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "935948.KE386493_gene2301";
/// let this_library_node_name2 = "935948.KE386495_gene2300";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldanaerobius_polysaccharolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldanaerobius_polysaccharolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldanaerobius_polysaccharolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldanaerobius_polysaccharolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["935948"]),
        None,
        Some("."),
        Some("KE38649"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizopus delemar nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936053.I1BGG9";
/// let this_library_node_name2 = "936053.P0C1J8";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizopus_delemar_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizopus_delemar_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizopus_delemar_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizopus_delemar_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936053"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium leguminosarum 248 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936136.ARRT01000001_gene1";
/// let this_library_node_name2 = "936136.ARRT01000007_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_leguminosarum_248_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_leguminosarum_248_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_leguminosarum_248_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_leguminosarum_248_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936136"]),
        None,
        Some("."),
        Some("ARRT0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus farciminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936140.AEOT01000001_gene2355";
/// let this_library_node_name2 = "936140.AEOT01000035_gene2097";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_farciminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_farciminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_farciminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_farciminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936140"]),
        None,
        Some("."),
        Some("AEOT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus parauberis KCTC11537 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936154.STP_0001";
/// let this_library_node_name2 = "936154.STP_1868";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_parauberis_kctc11537_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_parauberis_kctc11537_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_parauberis_kctc11537_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_parauberis_kctc11537_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936154"]),
        None,
        Some("."),
        Some("STP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter felis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936155.HFELIS_00010";
/// let this_library_node_name2 = "936155.HFELIS_16780";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_felis_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_felis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_felis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_felis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936155"]),
        None,
        Some("."),
        Some("HFELIS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mogibacterium sp. CM50 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936375.HMPREF1152_0001";
/// let this_library_node_name2 = "936375.HMPREF1152_1859";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mogibacterium_sp_cm50_node_name(this_library_node_name1));
/// assert!(is_valid_string_mogibacterium_sp_cm50_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mogibacterium_sp_cm50_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mogibacterium_sp_cm50_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936375"]),
        None,
        Some("."),
        Some("HMPREF1152_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium genosp. nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936455.KI421499_gene1";
/// let this_library_node_name2 = "936455.KI421499_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_genosp_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_genosp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_genosp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_genosp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936455"]),
        None,
        Some("."),
        Some("KI421499_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. ICM47 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936548.HMPREF1136_0001";
/// let this_library_node_name2 = "936548.HMPREF1136_2138";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_icm47_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_icm47_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_icm47_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_icm47_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936548"]),
        None,
        Some("."),
        Some("HMPREF1136_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atopobium sp. BS2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936550.HMPREF1492_0001";
/// let this_library_node_name2 = "936550.HMPREF1492_1473";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atopobium_sp_bs2_node_name(this_library_node_name1));
/// assert!(is_valid_string_atopobium_sp_bs2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atopobium_sp_bs2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atopobium_sp_bs2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936550"]),
        None,
        Some("."),
        Some("HMPREF1492_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas sp. FOBRC6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936572.HMPREF1148_0001";
/// let this_library_node_name2 = "936572.HMPREF1148_2376";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_sp_fobrc6_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_sp_fobrc6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_sp_fobrc6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_sp_fobrc6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936572"]),
        None,
        Some("."),
        Some("HMPREF1148_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas sp. FOBRC9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936573.HMPREF1147_0001";
/// let this_library_node_name2 = "936573.HMPREF1147_2372";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_sp_fobrc9_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_sp_fobrc9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_sp_fobrc9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_sp_fobrc9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936573"]),
        None,
        Some("."),
        Some("HMPREF1147_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shuttleworthia sp. MSX8B nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936574.HMPREF1508_0001";
/// let this_library_node_name2 = "936574.HMPREF1508_2053";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shuttleworthia_sp_msx8b_node_name(this_library_node_name1));
/// assert!(is_valid_string_shuttleworthia_sp_msx8b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shuttleworthia_sp_msx8b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shuttleworthia_sp_msx8b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936574"]),
        None,
        Some("."),
        Some("HMPREF1508_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. CM6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936580.HMPREF1516_0001";
/// let this_library_node_name2 = "936580.HMPREF1516_1952";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_cm6_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_cm6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_cm6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_cm6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936580"]),
        None,
        Some("."),
        Some("HMPREF1516_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Veillonella sp. AS16 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936589.HMPREF1521_0001";
/// let this_library_node_name2 = "936589.HMPREF1521_1790";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_veillonella_sp_as16_node_name(this_library_node_name1));
/// assert!(is_valid_string_veillonella_sp_as16_node_name(this_library_node_name2));
/// assert!(!is_valid_string_veillonella_sp_as16_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_veillonella_sp_as16_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936589"]),
        None,
        Some("."),
        Some("HMPREF1521_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnoanaerobaculum sp. MSX33 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "936596.HMPREF1495_0001";
/// let this_library_node_name2 = "936596.HMPREF1495_2742";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnoanaerobaculum_sp_msx33_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnoanaerobaculum_sp_msx33_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnoanaerobaculum_sp_msx33_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnoanaerobaculum_sp_msx33_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["936596"]),
        None,
        Some("."),
        Some("HMPREF1495_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Taylorella equigenitalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "937774.TEQUI_0001";
/// let this_library_node_name2 = "937774.TEQUI_1603";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_taylorella_equigenitalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_taylorella_equigenitalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_taylorella_equigenitalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_taylorella_equigenitalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["937774"]),
        None,
        Some("."),
        Some("TEQUI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus peraridilitoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "937777.Deipe_0001";
/// let this_library_node_name2 = "937777.Deipe_3825";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_peraridilitoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_peraridilitoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_peraridilitoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_peraridilitoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["937777"]),
        None,
        Some("."),
        Some("Deipe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium 9400853 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "938278.CAJO01000001_gene592";
/// let this_library_node_name2 = "938278.CAJO01000129_gene1411";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_9400853_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_9400853_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_9400853_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_9400853_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["938278"]),
        None,
        Some("."),
        Some("CAJO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium 9401234 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "938288.HG326224_gene1317";
/// let this_library_node_name2 = "938288.HG326230_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_9401234_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_9401234_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_9401234_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_9401234_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["938288"]),
        None,
        Some("."),
        Some("HG3262"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium 9403326 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "938289.CAJN020000001_gene1099";
/// let this_library_node_name2 = "938289.CAJN020000009_gene75";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_9403326_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_9403326_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_9403326_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_9403326_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["938289"]),
        None,
        Some("."),
        Some("CAJN02000000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerococcus sp. 9402080 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "938293.CAJU020000001_gene1";
/// let this_library_node_name2 = "938293.CAJU020000026_gene703";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerococcus_sp_9402080_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerococcus_sp_9402080_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerococcus_sp_9402080_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerococcus_sp_9402080_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["938293"]),
        None,
        Some("."),
        Some("CAJU0200000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroidetes bacterium SCGC AAA027N21 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "938709.AUSH02000001_gene1577";
/// let this_library_node_name2 = "938709.AUSH02000078_gene1848";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroidetes_bacterium_scgc_aaa027n21_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroidetes_bacterium_scgc_aaa027n21_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroidetes_bacterium_scgc_aaa027n21_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroidetes_bacterium_scgc_aaa027n21_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["938709"]),
        None,
        Some("."),
        Some("AUSH020000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetobacter pasteurianus 3P3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "940282.CADQ01000001_gene505";
/// let this_library_node_name2 = "940282.CADQ01000101_gene1835";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetobacter_pasteurianus_3p3_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetobacter_pasteurianus_3p3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetobacter_pasteurianus_3p3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetobacter_pasteurianus_3p3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["940282"]),
        None,
        Some("."),
        Some("CADQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio sp. X2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "941449.dsx2_0001";
/// let this_library_node_name2 = "941449.dsx2_3447";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_sp_x2_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_sp_x2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_sp_x2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_sp_x2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["941449"]),
        None,
        Some("."),
        Some("dsx2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus coagulans 26 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "941639.BCO26_0001";
/// let this_library_node_name2 = "941639.BCO26_2975";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_coagulans_26_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_coagulans_26_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_coagulans_26_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_coagulans_26_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["941639"]),
        None,
        Some("."),
        Some("BCO26_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus fructivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "941770.GL622178_gene1";
/// let this_library_node_name2 = "941770.GL622182_gene1352";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_fructivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_fructivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_fructivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_fructivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["941770"]),
        None,
        Some("."),
        Some("GL6221"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermobrachium celere nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "941824.TCEL_00001";
/// let this_library_node_name2 = "941824.TCEL_02382";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermobrachium_celere_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermobrachium_celere_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermobrachium_celere_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermobrachium_celere_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["941824"]),
        None,
        Some("."),
        Some("TCEL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sp. WSM2230 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "944435.AXAJ01000001_gene1";
/// let this_library_node_name2 = "944435.AXAJ01000033_gene1891";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sp_wsm2230_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sp_wsm2230_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sp_wsm2230_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sp_wsm2230_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["944435"]),
        None,
        Some("."),
        Some("AXAJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hippea jasoniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "944479.JQLX01000001_gene1201";
/// let this_library_node_name2 = "944479.JQLX01000018_gene195";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hippea_jasoniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_hippea_jasoniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hippea_jasoniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hippea_jasoniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["944479"]),
        None,
        Some("."),
        Some("JQLX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hippea alviniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "944480.ATUV01000001_gene1000";
/// let this_library_node_name2 = "944480.ATUV01000003_gene1771";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hippea_alviniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_hippea_alviniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hippea_alviniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hippea_alviniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["944480"]),
        None,
        Some("."),
        Some("ATUV0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hippea sp. KM1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "944481.JAFP01000001_gene1";
/// let this_library_node_name2 = "944481.JAFP01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hippea_sp_km1_node_name(this_library_node_name1));
/// assert!(is_valid_string_hippea_sp_km1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hippea_sp_km1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hippea_sp_km1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["944481"]),
        None,
        Some("."),
        Some("JAFP01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arcobacter butzleri ED1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "944546.ABED_0001";
/// let this_library_node_name2 = "944546.ABED_2158";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arcobacter_butzleri_ed1_node_name(this_library_node_name1));
/// assert!(is_valid_string_arcobacter_butzleri_ed1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arcobacter_butzleri_ed1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arcobacter_butzleri_ed1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["944546"]),
        None,
        Some("."),
        Some("ABED_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arcobacter sp. L nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "944547.ABLL_0001";
/// let this_library_node_name2 = "944547.ABLL_P1_0003";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arcobacter_sp_l_node_name(this_library_node_name1));
/// assert!(is_valid_string_arcobacter_sp_l_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arcobacter_sp_l_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arcobacter_sp_l_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["944547"]),
        None,
        Some("."),
        Some("ABLL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. F0384 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "944560.HMPREF9058_0001";
/// let this_library_node_name2 = "944560.HMPREF9058_2712";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_f0384_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_f0384_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_f0384_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_f0384_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["944560"]),
        None,
        Some("."),
        Some("HMPREF9058_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus oris F0423 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "944562.HMPREF9102_0003";
/// let this_library_node_name2 = "944562.HMPREF9102_2166";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_oris_f0423_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_oris_f0423_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_oris_f0423_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_oris_f0423_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["944562"]),
        None,
        Some("."),
        Some("HMPREF9102_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Veillonella sp. F0422 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "944564.HMPREF9200_0002";
/// let this_library_node_name2 = "944564.HMPREF9200_1663";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_veillonella_sp_f0422_node_name(this_library_node_name1));
/// assert!(is_valid_string_veillonella_sp_f0422_node_name(this_library_node_name2));
/// assert!(!is_valid_string_veillonella_sp_f0422_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_veillonella_sp_f0422_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["944564"]),
        None,
        Some("."),
        Some("HMPREF9200_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parvimonas sp. F0440 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "944565.HMPREF9127_0001";
/// let this_library_node_name2 = "944565.HMPREF9127_1683";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parvimonas_sp_f0440_node_name(this_library_node_name1));
/// assert!(is_valid_string_parvimonas_sp_f0440_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parvimonas_sp_f0440_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parvimonas_sp_f0440_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["944565"]),
        None,
        Some("."),
        Some("HMPREF9127_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tetragenococcus halophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "945021.TEH_00010";
/// let this_library_node_name2 = "945021.TEH_25540";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tetragenococcus_halophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_tetragenococcus_halophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tetragenococcus_halophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tetragenococcus_halophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["945021"]),
        None,
        Some("."),
        Some("TEH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio brasiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "945543.VIBR0546_00005";
/// let this_library_node_name2 = "945543.VIBR0546_21905";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_brasiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_brasiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_brasiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_brasiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["945543"]),
        None,
        Some("."),
        Some("VIBR0546_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio sinaloensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "945550.VISI1226_00005";
/// let this_library_node_name2 = "945550.VISI1226_23227";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_sinaloensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_sinaloensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_sinaloensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_sinaloensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["945550"]),
        None,
        Some("."),
        Some("VISI1226_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium ulcerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "945712.CULC22_00001";
/// let this_library_node_name2 = "945712.CULC22_02354";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_ulcerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_ulcerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_ulcerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_ulcerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["945712"]),
        None,
        Some("."),
        Some("CULC22_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ignavibacterium album nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "945713.IALB_0001";
/// let this_library_node_name2 = "945713.IALB_3206";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ignavibacterium_album_node_name(this_library_node_name1));
/// assert!(is_valid_string_ignavibacterium_album_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ignavibacterium_album_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ignavibacterium_album_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["945713"]),
        None,
        Some("."),
        Some("IALB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Imtechella halotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "946077.W5A_00005";
/// let this_library_node_name2 = "946077.W5A_13555";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_imtechella_halotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_imtechella_halotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_imtechella_halotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_imtechella_halotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["946077"]),
        None,
        Some("."),
        Some("W5A_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanobacillus massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "946235.CAER01000001_gene750";
/// let this_library_node_name2 = "946235.CAER01000118_gene2336";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanobacillus_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanobacillus_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanobacillus_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanobacillus_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["946235"]),
        None,
        Some("."),
        Some("CAER01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salpingoeca rosetta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "946362.XP_004987434.1";
/// let this_library_node_name2 = "946362.XP_004999139.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salpingoeca_rosetta_node_name(this_library_node_name1));
/// assert!(is_valid_string_salpingoeca_rosetta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salpingoeca_rosetta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salpingoeca_rosetta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["946362"]),
        None,
        Some("."),
        Some("XP_0049"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Symbiobacter mobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "946483.Cenrod_0001";
/// let this_library_node_name2 = "946483.Cenrod_2719";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_symbiobacter_mobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_symbiobacter_mobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_symbiobacter_mobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_symbiobacter_mobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["946483"]),
        None,
        Some("."),
        Some("Cenrod_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia dilworthii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "948106.AWZT01000001_gene4902";
/// let this_library_node_name2 = "948106.AWZT01000141_gene1627";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_dilworthii_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_dilworthii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_dilworthii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_dilworthii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["948106"]),
        None,
        Some("."),
        Some("AWZT01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Avibacterium paragallinarum 72 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "948565.AFFP02000001_gene1000";
/// let this_library_node_name2 = "948565.AFFP02000072_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_avibacterium_paragallinarum_72_node_name(this_library_node_name1));
/// assert!(is_valid_string_avibacterium_paragallinarum_72_node_name(this_library_node_name2));
/// assert!(!is_valid_string_avibacterium_paragallinarum_72_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_avibacterium_paragallinarum_72_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["948565"]),
        None,
        Some("."),
        Some("AFFP020000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces venezuelae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "953739.SVEN_0001";
/// let this_library_node_name2 = "953739.SVEN_7455";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_venezuelae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_venezuelae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_venezuelae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_venezuelae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["953739"]),
        None,
        Some("."),
        Some("SVEN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cupriavidus taiwanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "977880.RALTA_A0001";
/// let this_library_node_name2 = "977880.pRALTA_CDS529926R";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cupriavidus_taiwanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_cupriavidus_taiwanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cupriavidus_taiwanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cupriavidus_taiwanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["977880"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium testaceum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "979556.MTES_0001";
/// let this_library_node_name2 = "979556.MTES_3676";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_testaceum_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_testaceum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_testaceum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_testaceum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["979556"]),
        None,
        Some("."),
        Some("MTES_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacteriaceae bacterium HQM9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "980584.AFPB01000001_gene3415";
/// let this_library_node_name2 = "980584.AFPB01000183_gene915";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacteriaceae_bacterium_hqm9_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacteriaceae_bacterium_hqm9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacteriaceae_bacterium_hqm9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacteriaceae_bacterium_hqm9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["980584"]),
        None,
        Some("."),
        Some("AFPB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Morus notabilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "981085.XP_010086530.1";
/// let this_library_node_name2 = "981085.XP_010113494.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_morus_notabilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_morus_notabilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_morus_notabilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_morus_notabilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["981085"]),
        None,
        Some("."),
        Some("XP_010"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. NCTC 7422 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "981223.AIED01000001_gene1695";
/// let this_library_node_name2 = "981223.AIED01000164_gene463";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_nctc_7422_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_nctc_7422_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_nctc_7422_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_nctc_7422_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["981223"]),
        None,
        Some("."),
        Some("AIED01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter lwoffii NCTC 5866 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "981327.F925_00001";
/// let this_library_node_name2 = "981327.F925_03106";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_lwoffii_nctc_5866_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_lwoffii_nctc_5866_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_lwoffii_nctc_5866_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_lwoffii_nctc_5866_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["981327"]),
        None,
        Some("."),
        Some("F925_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter ursingii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "981336.F944_00001";
/// let this_library_node_name2 = "981336.F944_03351";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_ursingii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_ursingii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_ursingii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_ursingii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["981336"]),
        None,
        Some("."),
        Some("F944_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptacidiphilus rugosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "981369.JQMJ01000001_gene6520";
/// let this_library_node_name2 = "981369.JQMJ01000004_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptacidiphilus_rugosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptacidiphilus_rugosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptacidiphilus_rugosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptacidiphilus_rugosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["981369"]),
        None,
        Some("."),
        Some("JQMJ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ornithinibacillus scapharcae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "981383.AEWH01000001_gene3539";
/// let this_library_node_name2 = "981383.AEWH01000075_gene3815";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ornithinibacillus_scapharcae_node_name(this_library_node_name1));
/// assert!(is_valid_string_ornithinibacillus_scapharcae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ornithinibacillus_scapharcae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ornithinibacillus_scapharcae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["981383"]),
        None,
        Some("."),
        Some("AEWH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruegeria conchae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "981384.AEYW01000001_gene1387";
/// let this_library_node_name2 = "981384.AEYW01000028_gene4291";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruegeria_conchae_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruegeria_conchae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruegeria_conchae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruegeria_conchae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["981384"]),
        None,
        Some("."),
        Some("AEYW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter fetus venerealis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "983328.AFGH01000001_gene1339";
/// let this_library_node_name2 = "983328.AFGH01000045_gene1338";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_fetus_venerealis_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_fetus_venerealis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_fetus_venerealis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_fetus_venerealis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["983328"]),
        None,
        Some("."),
        Some("AFGH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lacinutrix sp. 5H374 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "983544.Lacal_0001";
/// let this_library_node_name2 = "983544.Lacal_2982";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lacinutrix_sp_5h374_node_name(this_library_node_name1));
/// assert!(is_valid_string_lacinutrix_sp_5h374_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lacinutrix_sp_5h374_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lacinutrix_sp_5h374_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["983544"]),
        None,
        Some("."),
        Some("Lacal_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glaciecola sp. 4H37YE5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "983545.Glaag_0001";
/// let this_library_node_name2 = "983545.Glaag_4611";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glaciecola_sp_4h37ye5_node_name(this_library_node_name1));
/// assert!(is_valid_string_glaciecola_sp_4h37ye5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glaciecola_sp_4h37ye5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glaciecola_sp_4h37ye5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["983545"]),
        None,
        Some("."),
        Some("Glaag_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dokdonia sp. 4H375 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "983548.Krodi_0001";
/// let this_library_node_name2 = "983548.Krodi_2995";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dokdonia_sp_4h375_node_name(this_library_node_name1));
/// assert!(is_valid_string_dokdonia_sp_4h375_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dokdonia_sp_4h375_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dokdonia_sp_4h375_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["983548"]),
        None,
        Some("."),
        Some("Krodi_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rubrivivax gelatinosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "983917.RGE_00010";
/// let this_library_node_name2 = "983917.RGE_47060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rubrivivax_gelatinosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rubrivivax_gelatinosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rubrivivax_gelatinosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rubrivivax_gelatinosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["983917"]),
        None,
        Some("."),
        Some("RGE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novosphingobium nitrogenifigens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "983920.Y88_0001";
/// let this_library_node_name2 = "983920.Y88_3872";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novosphingobium_nitrogenifigens_node_name(this_library_node_name1));
/// assert!(is_valid_string_novosphingobium_nitrogenifigens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novosphingobium_nitrogenifigens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novosphingobium_nitrogenifigens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["983920"]),
        None,
        Some("."),
        Some("Y88_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saprospira grandis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "984262.SGRA_0002";
/// let this_library_node_name2 = "984262.SGRA_p0058";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saprospira_grandis_node_name(this_library_node_name1));
/// assert!(is_valid_string_saprospira_grandis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saprospira_grandis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saprospira_grandis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["984262"]),
        None,
        Some("."),
        Some("SGRA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus pseudintermedius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "984892.SPSE_0001";
/// let this_library_node_name2 = "984892.SPSE_2504";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_pseudintermedius_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_pseudintermedius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_pseudintermedius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_pseudintermedius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["984892"]),
        None,
        Some("."),
        Some("SPSE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Heterobasidion irregulare nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "984962.XP_009540254.1";
/// let this_library_node_name2 = "984962.XP_009553528.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_heterobasidion_irregulare_node_name(this_library_node_name1));
/// assert!(is_valid_string_heterobasidion_irregulare_node_name(this_library_node_name2));
/// assert!(!is_valid_string_heterobasidion_irregulare_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_heterobasidion_irregulare_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["984962"]),
        None,
        Some("."),
        Some("XP_0095"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vulcanisaeta moutnovskia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "985053.VMUT_0001";
/// let this_library_node_name2 = "985053.VMUT_2347";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vulcanisaeta_moutnovskia_node_name(this_library_node_name1));
/// assert!(is_valid_string_vulcanisaeta_moutnovskia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vulcanisaeta_moutnovskia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vulcanisaeta_moutnovskia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["985053"]),
        None,
        Some("."),
        Some("VMUT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruegeria halocynthiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "985054.JQEZ01000001_gene1781";
/// let this_library_node_name2 = "985054.JQEZ01000019_gene3955";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruegeria_halocynthiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruegeria_halocynthiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruegeria_halocynthiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruegeria_halocynthiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["985054"]),
        None,
        Some("."),
        Some("JQEZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gillisia sp. CAL575 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "985255.APHJ01000001_gene2134";
/// let this_library_node_name2 = "985255.APHJ01000054_gene2133";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gillisia_sp_cal575_node_name(this_library_node_name1));
/// assert!(is_valid_string_gillisia_sp_cal575_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gillisia_sp_cal575_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gillisia_sp_cal575_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["985255"]),
        None,
        Some("."),
        Some("APHJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus terrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "985665.HPL003_00005";
/// let this_library_node_name2 = "985665.HPL003_28005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_terrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_terrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_terrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_terrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["985665"]),
        None,
        Some("."),
        Some("HPL003_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus agnetis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "985762.SAGN_00005";
/// let this_library_node_name2 = "985762.SAGN_12044";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_agnetis_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_agnetis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_agnetis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_agnetis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["985762"]),
        None,
        Some("."),
        Some("SAGN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Odyssella thessalonicensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "985867.AEWF01000001_gene1686";
/// let this_library_node_name2 = "985867.AEWF01000020_gene362";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_odyssella_thessalonicensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_odyssella_thessalonicensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_odyssella_thessalonicensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_odyssella_thessalonicensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["985867"]),
        None,
        Some("."),
        Some("AEWF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldalkalibacillus thermarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "986075.CathTA2_0001";
/// let this_library_node_name2 = "986075.CathTA2_3105";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldalkalibacillus_thermarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldalkalibacillus_thermarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldalkalibacillus_thermarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldalkalibacillus_thermarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["986075"]),
        None,
        Some("."),
        Some("CathTA2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rubrivivax benzoatilyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "987059.RBXJA2T_00005";
/// let this_library_node_name2 = "987059.RBXJA2T_19678";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rubrivivax_benzoatilyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rubrivivax_benzoatilyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rubrivivax_benzoatilyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rubrivivax_benzoatilyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["987059"]),
        None,
        Some("."),
        Some("RBXJA2T_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lebetimonas sp. JS170 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "990073.ATHU01000001_gene1000";
/// let this_library_node_name2 = "990073.ATHU01000005_gene1883";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lebetimonas_sp_js170_node_name(this_library_node_name1));
/// assert!(is_valid_string_lebetimonas_sp_js170_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lebetimonas_sp_js170_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lebetimonas_sp_js170_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["990073"]),
        None,
        Some("."),
        Some("ATHU0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium grahamii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "990285.RGCCGE502_00005";
/// let this_library_node_name2 = "990285.RGCCGE502_35048";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_grahamii_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_grahamii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_grahamii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_grahamii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["990285"]),
        None,
        Some("."),
        Some("RGCCGE502_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polymorphum gilvum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "991905.SL003B_0001";
/// let this_library_node_name2 = "991905.SL003B_p0071";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polymorphum_gilvum_node_name(this_library_node_name1));
/// assert!(is_valid_string_polymorphum_gilvum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polymorphum_gilvum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polymorphum_gilvum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["991905"]),
        None,
        Some("."),
        Some("SL003B_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Riemerella anatipestifer nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "992406.RIA_0001";
/// let this_library_node_name2 = "992406.RIA_2156";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_riemerella_anatipestifer_node_name(this_library_node_name1));
/// assert!(is_valid_string_riemerella_anatipestifer_node_name(this_library_node_name2));
/// assert!(!is_valid_string_riemerella_anatipestifer_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_riemerella_anatipestifer_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["992406"]),
        None,
        Some("."),
        Some("RIA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharopolyspora spinosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "994479.GL877878_gene100";
/// let this_library_node_name2 = "994479.GL877899_gene17";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharopolyspora_spinosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharopolyspora_spinosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharopolyspora_spinosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharopolyspora_spinosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["994479"]),
        None,
        Some("."),
        Some("GL8778"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Youngiibacter fragilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "994573.T472_0200005";
/// let this_library_node_name2 = "994573.T472_0219870";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_youngiibacter_fragilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_youngiibacter_fragilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_youngiibacter_fragilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_youngiibacter_fragilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["994573"]),
        None,
        Some("."),
        Some("T472_02"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus suis R61 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "996306.SSUR61_0001";
/// let this_library_node_name2 = "996306.SSUR61_2379";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_suis_r61_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_suis_r61_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_suis_r61_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_suis_r61_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["996306"]),
        None,
        Some("."),
        Some("SSUR61_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces griseoaurantiacus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "996637.SGM_0001";
/// let this_library_node_name2 = "996637.SGM_6839";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_griseoaurantiacus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_griseoaurantiacus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_griseoaurantiacus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_griseoaurantiacus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["996637"]),
        None,
        Some("."),
        Some("SGM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus methanolicus PB1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "997296.PB1_00005";
/// let this_library_node_name2 = "997296.PB1_17553";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_methanolicus_pb1_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_methanolicus_pb1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_methanolicus_pb1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_methanolicus_pb1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["997296"]),
        None,
        Some("."),
        Some("PB1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desmospora sp. 8437 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "997346.HMPREF9374_0001";
/// let this_library_node_name2 = "997346.HMPREF9374_4049";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desmospora_sp_8437_node_name(this_library_node_name1));
/// assert!(is_valid_string_desmospora_sp_8437_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desmospora_sp_8437_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desmospora_sp_8437_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["997346"]),
        None,
        Some("."),
        Some("HMPREF9374_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus indolicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "997350.HMPREF9129_0001";
/// let this_library_node_name2 = "997350.HMPREF9129_2269";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_indolicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_indolicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_indolicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_indolicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["997350"]),
        None,
        Some("."),
        Some("HMPREF9129_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella nigrescens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "997352.HMPREF9419_0001";
/// let this_library_node_name2 = "997352.HMPREF9419_2423";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_nigrescens_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_nigrescens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_nigrescens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_nigrescens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["997352"]),
        None,
        Some("."),
        Some("HMPREF9419_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella pallens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "997353.HMPREF9144_0001";
/// let this_library_node_name2 = "997353.HMPREF9144_2862";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_pallens_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_pallens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_pallens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_pallens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["997353"]),
        None,
        Some("."),
        Some("HMPREF9144_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas sp. KLE1280 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "997829.HMPREF1121_00002";
/// let this_library_node_name2 = "997829.HMPREF1121_01818";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_sp_kle1280_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_sp_kle1280_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_sp_kle1280_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_sp_kle1280_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["997829"]),
        None,
        Some("."),
        Some("HMPREF1121_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus infantis X nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "997830.HMPREF1124_0006";
/// let this_library_node_name2 = "997830.HMPREF1124_2010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_infantis_x_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_infantis_x_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_infantis_x_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_infantis_x_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["997830"]),
        None,
        Some("."),
        Some("HMPREF1124_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides nordii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "997884.HMPREF1068_00001";
/// let this_library_node_name2 = "997884.HMPREF1068_04420";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_nordii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_nordii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_nordii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_nordii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["997884"]),
        None,
        Some("."),
        Some("HMPREF1068_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aeromonas veronii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "998088.B565_0001";
/// let this_library_node_name2 = "998088.B565_4028";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aeromonas_veronii_node_name(this_library_node_name1));
/// assert!(is_valid_string_aeromonas_veronii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aeromonas_veronii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aeromonas_veronii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["998088"]),
        None,
        Some("."),
        Some("B565_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leucothrix mucor nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "998674.ATTE01000001_gene100";
/// let this_library_node_name2 = "998674.ATTE01000002_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leucothrix_mucor_node_name(this_library_node_name1));
/// assert!(is_valid_string_leucothrix_mucor_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leucothrix_mucor_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leucothrix_mucor_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["998674"]),
        None,
        Some("."),
        Some("ATTE0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas sp. TD01 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999141.GME_00005";
/// let this_library_node_name2 = "999141.GME_19314";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_sp_td01_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_sp_td01_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_sp_td01_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_sp_td01_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999141"]),
        None,
        Some("."),
        Some("GME_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium colicanis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999411.HMPREF1092_00002";
/// let this_library_node_name2 = "999411.HMPREF1092_03376";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_colicanis_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_colicanis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_colicanis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_colicanis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999411"]),
        None,
        Some("."),
        Some("HMPREF1092_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium innocuum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999413.HMPREF1094_00001";
/// let this_library_node_name2 = "999413.HMPREF1094_04726";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_innocuum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_innocuum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_innocuum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_innocuum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999413"]),
        None,
        Some("."),
        Some("HMPREF1094_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eggerthia catenaformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999415.HMPREF9943_00001";
/// let this_library_node_name2 = "999415.HMPREF9943_01884";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eggerthia_catenaformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_eggerthia_catenaformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eggerthia_catenaformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eggerthia_catenaformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999415"]),
        None,
        Some("."),
        Some("HMPREF9943_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parabacteroides johnsonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999419.HMPREF1077_00001";
/// let this_library_node_name2 = "999419.HMPREF1077_03758";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parabacteroides_johnsonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_parabacteroides_johnsonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parabacteroides_johnsonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parabacteroides_johnsonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999419"]),
        None,
        Some("."),
        Some("HMPREF1077_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas sp. F0473 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999423.HMPREF9161_00001";
/// let this_library_node_name2 = "999423.HMPREF9161_01886";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_sp_f0473_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_sp_f0473_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_sp_f0473_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_sp_f0473_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999423"]),
        None,
        Some("."),
        Some("HMPREF9161_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. F0442 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999425.HMPREF9186_00001";
/// let this_library_node_name2 = "999425.HMPREF9186_02146";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_f0442_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_f0442_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_f0442_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_f0442_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999425"]),
        None,
        Some("."),
        Some("HMPREF9186_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia gladioli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999541.bgla_1g00010";
/// let this_library_node_name2 = "999541.bgla_2p1100";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_gladioli_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_gladioli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_gladioli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_gladioli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999541"]),
        None,
        Some("."),
        Some("bgla_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leisingera daeponensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999547.KI421500_gene1000";
/// let this_library_node_name2 = "999547.KI421503_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leisingera_daeponensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_leisingera_daeponensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leisingera_daeponensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leisingera_daeponensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999547"]),
        None,
        Some("."),
        Some("KI42150"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leisingera caerulea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999549.KI421513_gene1000";
/// let this_library_node_name2 = "999549.KI421515_gene466";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leisingera_caerulea_node_name(this_library_node_name1));
/// assert!(is_valid_string_leisingera_caerulea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leisingera_caerulea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leisingera_caerulea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999549"]),
        None,
        Some("."),
        Some("KI42151"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudophaeobacter arcticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999550.KI421507_gene1";
/// let this_library_node_name2 = "999550.KI421507_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudophaeobacter_arcticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudophaeobacter_arcticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudophaeobacter_arcticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudophaeobacter_arcticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999550"]),
        None,
        Some("."),
        Some("KI421507_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leisingera aquimarina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999611.KI421504_gene1";
/// let this_library_node_name2 = "999611.KI421506_gene4047";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leisingera_aquimarina_node_name(this_library_node_name1));
/// assert!(is_valid_string_leisingera_aquimarina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leisingera_aquimarina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leisingera_aquimarina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999611"]),
        None,
        Some("."),
        Some("KI42150"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoproteus uzoniensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "999630.TUZN_0001";
/// let this_library_node_name2 = "999630.TUZN_2242";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoproteus_uzoniensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoproteus_uzoniensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoproteus_uzoniensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoproteus_uzoniensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["999630"]),
        None,
        Some("."),
        Some("TUZN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methyloversatilis universalis FAM5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1000565.METUNv1_00006";
/// let this_library_node_name2 = "1000565.METUNv1_04065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methyloversatilis_universalis_fam5_node_name(this_library_node_name1));
/// assert!(is_valid_string_methyloversatilis_universalis_fam5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methyloversatilis_universalis_fam5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methyloversatilis_universalis_fam5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1000565"]),
        None,
        Some("."),
        Some("METUNv1_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Megasphaera sp. UPII135E nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1000569.HMPREF1040_0002";
/// let this_library_node_name2 = "1000569.HMPREF1040_1619";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_megasphaera_sp_upii135e_node_name(this_library_node_name1));
/// assert!(is_valid_string_megasphaera_sp_upii135e_node_name(this_library_node_name2));
/// assert!(!is_valid_string_megasphaera_sp_upii135e_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_megasphaera_sp_upii135e_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1000569"]),
        None,
        Some("."),
        Some("HMPREF1040_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus anginosus SK52 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1000570.HMPREF9966_0001";
/// let this_library_node_name2 = "1000570.HMPREF9966_1967";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_anginosus_sk52_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_anginosus_sk52_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_anginosus_sk52_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_anginosus_sk52_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1000570"]),
        None,
        Some("."),
        Some("HMPREF9966_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis 2 SK95 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1000588.HMPREF9965_0001";
/// let this_library_node_name2 = "1000588.HMPREF9965_2065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_2_sk95_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_2_sk95_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_2_sk95_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_2_sk95_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1000588"]),
        None,
        Some("."),
        Some("HMPREF9965_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cryobacterium roopkundense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1001240.GY21_00005";
/// let this_library_node_name2 = "1001240.GY21_21340";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cryobacterium_roopkundense_node_name(this_library_node_name1));
/// assert!(is_valid_string_cryobacterium_roopkundense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cryobacterium_roopkundense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cryobacterium_roopkundense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1001240"]),
        None,
        Some("."),
        Some("GY21_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photobacterium leiognathi mandapamensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1001530.BACE01000001_gene3512";
/// let this_library_node_name2 = "1001530.BACE01000031_gene1713";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photobacterium_leiognathi_mandapamensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_photobacterium_leiognathi_mandapamensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photobacterium_leiognathi_mandapamensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photobacterium_leiognathi_mandapamensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1001530"]),
        None,
        Some("."),
        Some("BACE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas mendocina NK01 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1001585.MDS_0001";
/// let this_library_node_name2 = "1001585.MDS_4958";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_mendocina_nk01_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_mendocina_nk01_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_mendocina_nk01_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_mendocina_nk01_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1001585"]),
        None,
        Some("."),
        Some("MDS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter sp. 1501 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1002339.HMPREF9373_0001";
/// let this_library_node_name2 = "1002339.HMPREF9373_2661";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_sp_1501_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_sp_1501_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_sp_1501_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_sp_1501_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1002339"]),
        None,
        Some("."),
        Some("HMPREF9373_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leisingera sp. ANG1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1002340.AFCF01000001_gene2869";
/// let this_library_node_name2 = "1002340.AFCF01000131_gene2001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leisingera_sp_ang1_node_name(this_library_node_name1));
/// assert!(is_valid_string_leisingera_sp_ang1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leisingera_sp_ang1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leisingera_sp_ang1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1002340"]),
        None,
        Some("."),
        Some("AFCF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella stercorea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1002367.HMPREF0673_00001";
/// let this_library_node_name2 = "1002367.HMPREF0673_03067";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_stercorea_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_stercorea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_stercorea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_stercorea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1002367"]),
        None,
        Some("."),
        Some("HMPREF0673_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibacter sp. IMCC9063 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1002672.SAR11G3_00001";
/// let this_library_node_name2 = "1002672.SAR11G3_01447";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibacter_sp_imcc9063_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibacter_sp_imcc9063_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibacter_sp_imcc9063_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibacter_sp_imcc9063_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1002672"]),
        None,
        Some("."),
        Some("SAR11G3_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter bizzozeronii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1002804.HBZC1_00010";
/// let this_library_node_name2 = "1002804.HBZC1_p0770";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_bizzozeronii_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_bizzozeronii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_bizzozeronii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_bizzozeronii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1002804"]),
        None,
        Some("."),
        Some("HBZC1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solibacillus silvestris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1002809.SSIL_0001";
/// let this_library_node_name2 = "1002809.SSIL_3810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solibacillus_silvestris_node_name(this_library_node_name1));
/// assert!(is_valid_string_solibacillus_silvestris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solibacillus_silvestris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solibacillus_silvestris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1002809"]),
        None,
        Some("."),
        Some("SSIL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces cattleya nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1003195.SCAT_0001";
/// let this_library_node_name2 = "1003195.SCAT_5822";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_cattleya_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_cattleya_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_cattleya_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_cattleya_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1003195"]),
        None,
        Some("."),
        Some("SCAT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Achromobacter insuavis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1003200.AXXA_00005";
/// let this_library_node_name2 = "1003200.AXXA_31193";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_achromobacter_insuavis_node_name(this_library_node_name1));
/// assert!(is_valid_string_achromobacter_insuavis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_achromobacter_insuavis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_achromobacter_insuavis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1003200"]),
        None,
        Some("."),
        Some("AXXA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesoflavibacter zeaxanth. S86 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1004149.AFOE01000001_gene2923";
/// let this_library_node_name2 = "1004149.AFOE01000061_gene1595";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesoflavibacter_zeaxanth_s86_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesoflavibacter_zeaxanth_s86_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesoflavibacter_zeaxanth_s86_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesoflavibacter_zeaxanth_s86_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1004149"]),
        None,
        Some("."),
        Some("AFOE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alteromonas macleodii Black nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1004785.AMBLS11_00005";
/// let this_library_node_name2 = "1004785.AMBLS11_19025";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alteromonas_macleodii_black_node_name(this_library_node_name1));
/// assert!(is_valid_string_alteromonas_macleodii_black_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alteromonas_macleodii_black_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alteromonas_macleodii_black_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1004785"]),
        None,
        Some("."),
        Some("AMBLS11_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Collimonas fungivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005048.CFU_0001";
/// let this_library_node_name2 = "1005048.CFU_4450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_collimonas_fungivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_collimonas_fungivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_collimonas_fungivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_collimonas_fungivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005048"]),
        None,
        Some("."),
        Some("CFU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Buchnera aphidicola Ua nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005057.BUAMB_001";
/// let this_library_node_name2 = "1005057.BUAMB_580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_buchnera_aphidicola_ua_node_name(this_library_node_name1));
/// assert!(is_valid_string_buchnera_aphidicola_ua_node_name(this_library_node_name2));
/// assert!(!is_valid_string_buchnera_aphidicola_ua_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_buchnera_aphidicola_ua_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005057"]),
        None,
        Some("."),
        Some("BUAMB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gallibacterium anatis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005058.UMN179_00002";
/// let this_library_node_name2 = "1005058.UMN179_p00006";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gallibacterium_anatis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gallibacterium_anatis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gallibacterium_anatis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gallibacterium_anatis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005058"]),
        None,
        Some("."),
        Some("UMN179_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Buchnera aphidicola Ak nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005090.BAKON_001";
/// let this_library_node_name2 = "1005090.BAKON_616";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_buchnera_aphidicola_ak_node_name(this_library_node_name1));
/// assert!(is_valid_string_buchnera_aphidicola_ak_node_name(this_library_node_name2));
/// assert!(!is_valid_string_buchnera_aphidicola_ak_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_buchnera_aphidicola_ak_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005090"]),
        None,
        Some("."),
        Some("BAKON_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas putida CSV86 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005395.CSV86_00007";
/// let this_library_node_name2 = "1005395.CSV86_29442";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_putida_csv86_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_putida_csv86_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_putida_csv86_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_putida_csv86_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005395"]),
        None,
        Some("."),
        Some("CSV86_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus oralis SK255 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005704.HMPREF9968_0001";
/// let this_library_node_name2 = "1005704.HMPREF9968_2101";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_oralis_sk255_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_oralis_sk255_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_oralis_sk255_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_oralis_sk255_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005704"]),
        None,
        Some("."),
        Some("HMPREF9968_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus infantis SK1076 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005705.HMPREF9967_0001";
/// let this_library_node_name2 = "1005705.HMPREF9967_1837";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_infantis_sk1076_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_infantis_sk1076_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_infantis_sk1076_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_infantis_sk1076_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005705"]),
        None,
        Some("."),
        Some("HMPREF9967_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ogataea parapolymorpha nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005962.E7E825";
/// let this_library_node_name2 = "1005962.W1QLW5";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ogataea_parapolymorpha_node_name(this_library_node_name1));
/// assert!(is_valid_string_ogataea_parapolymorpha_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ogataea_parapolymorpha_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ogataea_parapolymorpha_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005962"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Trabulsiella guamensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005994.GTGU_00001";
/// let this_library_node_name2 = "1005994.GTGU_04826";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_trabulsiella_guamensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_trabulsiella_guamensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_trabulsiella_guamensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_trabulsiella_guamensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005994"]),
        None,
        Some("."),
        Some("GTGU_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tatumella ptyseos nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005995.GTPT_0001";
/// let this_library_node_name2 = "1005995.GTPT_3418";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tatumella_ptyseos_node_name(this_library_node_name1));
/// assert!(is_valid_string_tatumella_ptyseos_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tatumella_ptyseos_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tatumella_ptyseos_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005995"]),
        None,
        Some("."),
        Some("GTPT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leminorella grimontii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1005999.GLGR_0001";
/// let this_library_node_name2 = "1005999.GLGR_3828";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leminorella_grimontii_node_name(this_library_node_name1));
/// assert!(is_valid_string_leminorella_grimontii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leminorella_grimontii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leminorella_grimontii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1005999"]),
        None,
        Some("."),
        Some("GLGR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kluyvera ascorbata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1006000.GKAS_00001";
/// let this_library_node_name2 = "1006000.GKAS_04730";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kluyvera_ascorbata_node_name(this_library_node_name1));
/// assert!(is_valid_string_kluyvera_ascorbata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kluyvera_ascorbata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kluyvera_ascorbata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1006000"]),
        None,
        Some("."),
        Some("GKAS_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Buttiauxella agrestis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1006004.GBAG_0001";
/// let this_library_node_name2 = "1006004.GBAG_4419";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_buttiauxella_agrestis_node_name(this_library_node_name1));
/// assert!(is_valid_string_buttiauxella_agrestis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_buttiauxella_agrestis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_buttiauxella_agrestis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1006004"]),
        None,
        Some("."),
        Some("GBAG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Metallosphaera cuprina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1006006.Mcup_0001";
/// let this_library_node_name2 = "1006006.Mcup_2039";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_metallosphaera_cuprina_node_name(this_library_node_name1));
/// assert!(is_valid_string_metallosphaera_cuprina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_metallosphaera_cuprina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_metallosphaera_cuprina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1006006"]),
        None,
        Some("."),
        Some("Mcup_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma gallisepticum S6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1006581.GCW_00005";
/// let this_library_node_name2 = "1006581.GCW_99046";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_gallisepticum_s6_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_gallisepticum_s6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_gallisepticum_s6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_gallisepticum_s6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1006581"]),
        None,
        Some("."),
        Some("GCW_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oscillibacter ruminantium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1007096.BAGW01000001_gene265";
/// let this_library_node_name2 = "1007096.BAGW01000057_gene12";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oscillibacter_ruminantium_node_name(this_library_node_name1));
/// assert!(is_valid_string_oscillibacter_ruminantium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oscillibacter_ruminantium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oscillibacter_ruminantium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1007096"]),
        None,
        Some("."),
        Some("BAGW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus elgii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1007103.AFHW01000001_gene4820";
/// let this_library_node_name2 = "1007103.AFHW01000278_gene496";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_elgii_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_elgii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_elgii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_elgii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1007103"]),
        None,
        Some("."),
        Some("AFHW01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. S17 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1007104.SUS17_1";
/// let this_library_node_name2 = "1007104.SUS17_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_s17_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_s17_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_s17_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_s17_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1007104"]),
        None,
        Some("."),
        Some("SUS17_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pusillimonas sp. T77 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1007105.PT7_0001";
/// let this_library_node_name2 = "1007105.PT7_P077";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pusillimonas_sp_t77_node_name(this_library_node_name1));
/// assert!(is_valid_string_pusillimonas_sp_t77_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pusillimonas_sp_t77_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pusillimonas_sp_t77_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1007105"]),
        None,
        Some("."),
        Some("PT7_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis SK1080 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1008453.HMPREF9957_0001";
/// let this_library_node_name2 = "1008453.HMPREF9957_1969";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_sk1080_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_sk1080_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_sk1080_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_sk1080_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1008453"]),
        None,
        Some("."),
        Some("HMPREF9957_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myroides injenensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1008457.BAEX01000001_gene1176";
/// let this_library_node_name2 = "1008457.BAEX01000224_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myroides_injenensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_myroides_injenensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myroides_injenensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myroides_injenensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1008457"]),
        None,
        Some("."),
        Some("BAEX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Taylorella asinigenitalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1008459.TASI_0001";
/// let this_library_node_name2 = "1008459.TASI_1581";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_taylorella_asinigenitalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_taylorella_asinigenitalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_taylorella_asinigenitalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_taylorella_asinigenitalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1008459"]),
        None,
        Some("."),
        Some("TASI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetonema longum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1009370.ALO_00005";
/// let this_library_node_name2 = "1009370.ALO_21901";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetonema_longum_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetonema_longum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetonema_longum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetonema_longum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1009370"]),
        None,
        Some("."),
        Some("ALO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Buchnera aphidicola G002 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1009858.BUMPG002_CDS00001";
/// let this_library_node_name2 = "1009858.BUMPG002_pLeu00007";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_buchnera_aphidicola_g002_node_name(this_library_node_name1));
/// assert!(is_valid_string_buchnera_aphidicola_g002_node_name(this_library_node_name2));
/// assert!(!is_valid_string_buchnera_aphidicola_g002_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_buchnera_aphidicola_g002_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1009858"]),
        None,
        Some("."),
        Some("BUMPG002_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylophaga aminisulfidivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1026882.MAMP_00001";
/// let this_library_node_name2 = "1026882.MAMP_03174";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylophaga_aminisulfidivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylophaga_aminisulfidivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylophaga_aminisulfidivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylophaga_aminisulfidivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1026882"]),
        None,
        Some("."),
        Some("MAMP_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nannospalax galili nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1026970.XP_008819672.1";
/// let this_library_node_name2 = "1026970.XP_008854610.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nannospalax_galili_node_name(this_library_node_name1));
/// assert!(is_valid_string_nannospalax_galili_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nannospalax_galili_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nannospalax_galili_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1026970"]),
        None,
        Some("."),
        Some("XP_0088"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Endozoicomonas montiporae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1027273.GZ77_00010";
/// let this_library_node_name2 = "1027273.GZ77_26785";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_endozoicomonas_montiporae_node_name(this_library_node_name1));
/// assert!(is_valid_string_endozoicomonas_montiporae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_endozoicomonas_montiporae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_endozoicomonas_montiporae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1027273"]),
        None,
        Some("."),
        Some("GZ77_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporosarcina newyorkensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1027292.HMPREF9372_0001";
/// let this_library_node_name2 = "1027292.HMPREF9372_3826";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporosarcina_newyorkensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporosarcina_newyorkensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporosarcina_newyorkensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporosarcina_newyorkensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1027292"]),
        None,
        Some("."),
        Some("HMPREF9372_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia alkanivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1027371.GOALK_001_00010";
/// let this_library_node_name2 = "1027371.GOALK_131_00230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_alkanivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_alkanivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_alkanivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_alkanivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1027371"]),
        None,
        Some("."),
        Some("GOALK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeria monocytogenes Scott nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1027396.LMOSA_10";
/// let this_library_node_name2 = "1027396.LMOSA_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeria_monocytogenes_scott_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeria_monocytogenes_scott_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeria_monocytogenes_scott_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeria_monocytogenes_scott_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1027396"]),
        None,
        Some("."),
        Some("LMOSA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacter aerogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1028307.EAE_00010";
/// let this_library_node_name2 = "1028307.EAE_24795";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacter_aerogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacter_aerogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacter_aerogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacter_aerogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1028307"]),
        None,
        Some("."),
        Some("EAE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neorhizobium galegae orientalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1028800.RG540_CH00010";
/// let this_library_node_name2 = "1028800.RG540_PA16920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neorhizobium_galegae_orientalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_neorhizobium_galegae_orientalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neorhizobium_galegae_orientalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neorhizobium_galegae_orientalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1028800"]),
        None,
        Some("."),
        Some("RG540_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neorhizobium galegae officinalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1028801.RG1141_CH00010";
/// let this_library_node_name2 = "1028801.RG1141_PA15160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neorhizobium_galegae_officinalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_neorhizobium_galegae_officinalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neorhizobium_galegae_officinalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neorhizobium_galegae_officinalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1028801"]),
        None,
        Some("."),
        Some("RG1141_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haemophilus haemolyticus M19501 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1028803.GG9_0001";
/// let this_library_node_name2 = "1028803.GG9_1747";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haemophilus_haemolyticus_m19501_node_name(this_library_node_name1));
/// assert!(is_valid_string_haemophilus_haemolyticus_m19501_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haemophilus_haemolyticus_m19501_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haemophilus_haemolyticus_m19501_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1028803"]),
        None,
        Some("."),
        Some("GG9_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haemophilus haemolyticus M21621 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1028805.GGC_0001";
/// let this_library_node_name2 = "1028805.GGC_1894";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haemophilus_haemolyticus_m21621_node_name(this_library_node_name1));
/// assert!(is_valid_string_haemophilus_haemolyticus_m21621_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haemophilus_haemolyticus_m21621_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haemophilus_haemolyticus_m21621_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1028805"]),
        None,
        Some("."),
        Some("GGC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haemophilus haemolyticus M21639 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1028806.GGE_0001";
/// let this_library_node_name2 = "1028806.GGE_2224";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haemophilus_haemolyticus_m21639_node_name(this_library_node_name1));
/// assert!(is_valid_string_haemophilus_haemolyticus_m21639_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haemophilus_haemolyticus_m21639_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haemophilus_haemolyticus_m21639_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1028806"]),
        None,
        Some("."),
        Some("GGE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthromitus sp. SFBmouseJapan nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1029718.SFBM_0001";
/// let this_library_node_name2 = "1029718.SFBM_1515";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthromitus_sp_sfbmousejapan_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthromitus_sp_sfbmousejapan_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthromitus_sp_sfbmousejapan_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthromitus_sp_sfbmousejapan_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1029718"]),
        None,
        Some("."),
        Some("SFBM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. P838 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1029823.AFIE01000001_gene2048";
/// let this_library_node_name2 = "1029823.AFIE01000204_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_p838_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_p838_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_p838_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_p838_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1029823"]),
        None,
        Some("."),
        Some("AFIE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kocuria rhizophila P74 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1029824.AFID01000001_gene1780";
/// let this_library_node_name2 = "1029824.AFID01000054_gene943";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kocuria_rhizophila_p74_node_name(this_library_node_name1));
/// assert!(is_valid_string_kocuria_rhizophila_p74_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kocuria_rhizophila_p74_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kocuria_rhizophila_p74_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1029824"]),
        None,
        Some("."),
        Some("AFID010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. KC8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1030157.AFMP01000002_gene2129";
/// let this_library_node_name2 = "1030157.AFMP01000070_gene2214";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_kc8_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_kc8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_kc8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_kc8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1030157"]),
        None,
        Some("."),
        Some("AFMP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caloramator sp. ALD01 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1031288.AXAA01000001_gene2191";
/// let this_library_node_name2 = "1031288.AXAA01000068_gene762";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caloramator_sp_ald01_node_name(this_library_node_name1));
/// assert!(is_valid_string_caloramator_sp_ald01_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caloramator_sp_ald01_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caloramator_sp_ald01_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1031288"]),
        None,
        Some("."),
        Some("AXAA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ralstonia solanacearum Po82 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1031711.RSPO_c00001";
/// let this_library_node_name2 = "1031711.RSPO_c03351";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ralstonia_solanacearum_po82_node_name(this_library_node_name1));
/// assert!(is_valid_string_ralstonia_solanacearum_po82_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ralstonia_solanacearum_po82_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ralstonia_solanacearum_po82_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1031711"]),
        None,
        Some("."),
        Some("RSPO_c0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microlunatus phosphovorus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1032480.MLP_00010";
/// let this_library_node_name2 = "1032480.MLP_53590";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microlunatus_phosphovorus_node_name(this_library_node_name1));
/// assert!(is_valid_string_microlunatus_phosphovorus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microlunatus_phosphovorus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microlunatus_phosphovorus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1032480"]),
        None,
        Some("."),
        Some("MLP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aeromicrobium massiliense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033730.CAHG01000001_gene2532";
/// let this_library_node_name2 = "1033730.CAHG01000017_gene2466";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aeromicrobium_massiliense_node_name(this_library_node_name1));
/// assert!(is_valid_string_aeromicrobium_massiliense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aeromicrobium_massiliense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aeromicrobium_massiliense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033730"]),
        None,
        Some("."),
        Some("CAHG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alistipes senegalensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033732.CAHI01000001_gene291";
/// let this_library_node_name2 = "1033732.CAHI01000041_gene2463";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alistipes_senegalensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alistipes_senegalensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alistipes_senegalensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alistipes_senegalensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033732"]),
        None,
        Some("."),
        Some("CAHI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerococcus senegalensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033733.CAEK01000001_gene137";
/// let this_library_node_name2 = "1033733.CAEK01000039_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerococcus_senegalensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerococcus_senegalensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerococcus_senegalensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerococcus_senegalensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033733"]),
        None,
        Some("."),
        Some("CAEK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus timonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033734.CAET01000001_gene3929";
/// let this_library_node_name2 = "1033734.CAET01000146_gene2310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_timonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_timonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_timonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_timonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033734"]),
        None,
        Some("."),
        Some("CAET01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacterium senegalense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033736.CAHK01000001_gene351";
/// let this_library_node_name2 = "1033736.CAHK01000069_gene2923";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacterium_senegalense_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacterium_senegalense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacterium_senegalense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacterium_senegalense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033736"]),
        None,
        Some("."),
        Some("CAHK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium senegalense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033737.CAEV01000001_gene2263";
/// let this_library_node_name2 = "1033737.CAEV01000191_gene3236";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_senegalense_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_senegalense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_senegalense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_senegalense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033737"]),
        None,
        Some("."),
        Some("CAEV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kurthia sp. Dielmo nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033738.CAEP01000001_gene2410";
/// let this_library_node_name2 = "1033738.CAEP01000260_gene3577";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kurthia_sp_dielmo_node_name(this_library_node_name1));
/// assert!(is_valid_string_kurthia_sp_dielmo_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kurthia_sp_dielmo_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kurthia_sp_dielmo_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033738"]),
        None,
        Some("."),
        Some("CAEP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kurthia massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033739.CAEU01000001_gene1417";
/// let this_library_node_name2 = "1033739.CAEU01000115_gene871";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kurthia_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_kurthia_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kurthia_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kurthia_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033739"]),
        None,
        Some("."),
        Some("CAEU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kurthia sp. JC8E nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033740.CAEW01000001_gene1219";
/// let this_library_node_name2 = "1033740.CAEW01000072_gene4";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kurthia_sp_jc8e_node_name(this_library_node_name1));
/// assert!(is_valid_string_kurthia_sp_jc8e_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kurthia_sp_jc8e_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kurthia_sp_jc8e_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033740"]),
        None,
        Some("."),
        Some("CAEW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus senegalensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033743.CAES01000001_gene1677";
/// let this_library_node_name2 = "1033743.CAES01000196_gene1428";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_senegalensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_senegalensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_senegalensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_senegalensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033743"]),
        None,
        Some("."),
        Some("CAES01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus senegalensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033744.CAEL01000001_gene390";
/// let this_library_node_name2 = "1033744.CAEL01000059_gene1745";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_senegalensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_senegalensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_senegalensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_senegalensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033744"]),
        None,
        Some("."),
        Some("CAEL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinisphaera shabanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033802.SSPSH_000001";
/// let this_library_node_name2 = "1033802.SSPSH_003775";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinisphaera_shabanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinisphaera_shabanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinisphaera_shabanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinisphaera_shabanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033802"]),
        None,
        Some("."),
        Some("SSPSH_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halorhabdus tiamatea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033806.HTIA_0001";
/// let this_library_node_name2 = "1033806.HTIA_p3073";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halorhabdus_tiamatea_node_name(this_library_node_name1));
/// assert!(is_valid_string_halorhabdus_tiamatea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halorhabdus_tiamatea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halorhabdus_tiamatea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033806"]),
        None,
        Some("."),
        Some("HTIA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloplasma contractile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033810.HLPCO_000001";
/// let this_library_node_name2 = "1033810.HLPCO_003191";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloplasma_contractile_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloplasma_contractile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloplasma_contractile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloplasma_contractile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033810"]),
        None,
        Some("."),
        Some("HLPCO_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus kefiranofaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033837.WANG_0001";
/// let this_library_node_name2 = "1033837.WANG_p1199";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_kefiranofaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_kefiranofaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_kefiranofaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_kefiranofaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033837"]),
        None,
        Some("."),
        Some("WANG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium leguminosarum CB782 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1033991.RLEG12_01300";
/// let this_library_node_name2 = "1033991.RLEG12_33235";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_leguminosarum_cb782_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_leguminosarum_cb782_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_leguminosarum_cb782_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_leguminosarum_cb782_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1033991"]),
        None,
        Some("."),
        Some("RLEG12_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Senegalimassilia anaerobia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1034345.CAEM01000001_gene436";
/// let this_library_node_name2 = "1034345.CAEM01000084_gene911";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_senegalimassilia_anaerobia_node_name(this_library_node_name1));
/// assert!(is_valid_string_senegalimassilia_anaerobia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_senegalimassilia_anaerobia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_senegalimassilia_anaerobia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1034345"]),
        None,
        Some("."),
        Some("CAEM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus massiliosenegalensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1034347.CAHJ01000001_gene1186";
/// let this_library_node_name2 = "1034347.CAHJ01000102_gene12";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_massiliosenegalensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_massiliosenegalensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_massiliosenegalensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_massiliosenegalensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1034347"]),
        None,
        Some("."),
        Some("CAHJ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. HW567 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1034769.KB910518_gene1";
/// let this_library_node_name2 = "1034769.KB910518_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_hw567_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_hw567_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_hw567_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_hw567_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1034769"]),
        None,
        Some("."),
        Some("KB910518_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium branchiophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1034807.FBFL15_0001";
/// let this_library_node_name2 = "1034807.FBFL15_p0005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_branchiophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_branchiophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_branchiophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_branchiophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1034807"]),
        None,
        Some("."),
        Some("FBFL15_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma anatis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1034808.GIG_00005";
/// let this_library_node_name2 = "1034808.GIG_04161";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_anatis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_anatis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_anatis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_anatis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1034808"]),
        None,
        Some("."),
        Some("GIG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus lugdunensis N920143 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1034809.SLUG_00010";
/// let this_library_node_name2 = "1034809.SLUG_24410";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_lugdunensis_n920143_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_lugdunensis_n920143_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_lugdunensis_n920143_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_lugdunensis_n920143_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1034809"]),
        None,
        Some("."),
        Some("SLUG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1034943.BN1094_00001";
/// let this_library_node_name2 = "1034943.BN1094_03827";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1034943"]),
        None,
        Some("."),
        Some("BN1094_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus constellatus pharyngis SK1060 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1035184.HMPREF1042_0001";
/// let this_library_node_name2 = "1035184.HMPREF1042_2516";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_constellatus_pharyngis_sk1060_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_constellatus_pharyngis_sk1060_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_constellatus_pharyngis_sk1060_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_constellatus_pharyngis_sk1060_node_name(
    node_name: &str,
) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1035184"]),
        None,
        Some("."),
        Some("HMPREF1042_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis SK569 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1035187.HMPREF9959_0001";
/// let this_library_node_name2 = "1035187.HMPREF9959_1938";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_sk569_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_sk569_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_sk569_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_sk569_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1035187"]),
        None,
        Some("."),
        Some("HMPREF9959_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus infantis SK970 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1035189.HMPREF9954_0005";
/// let this_library_node_name2 = "1035189.HMPREF9954_2232";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_infantis_sk970_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_infantis_sk970_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_infantis_sk970_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_infantis_sk970_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1035189"]),
        None,
        Some("."),
        Some("HMPREF9954_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevundimonas diminuta 4704 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1035191.HMPREF0185_00001";
/// let this_library_node_name2 = "1035191.HMPREF0185_03556";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevundimonas_diminuta_4704_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevundimonas_diminuta_4704_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevundimonas_diminuta_4704_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevundimonas_diminuta_4704_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1035191"]),
        None,
        Some("."),
        Some("HMPREF0185_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga sp. F0382 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1035193.HMPREF9073_00001";
/// let this_library_node_name2 = "1035193.HMPREF9073_03274";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_sp_f0382_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_sp_f0382_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_sp_f0382_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_sp_f0382_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1035193"]),
        None,
        Some("."),
        Some("HMPREF9073_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium durum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1035195.HMPREF9997_00001";
/// let this_library_node_name2 = "1035195.HMPREF9997_02877";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_durum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_durum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_durum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_durum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1035195"]),
        None,
        Some("."),
        Some("HMPREF9997_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptostreptococcus anaerobius VPI4330 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1035196.HMPREF9998_00001";
/// let this_library_node_name2 = "1035196.HMPREF9998_01961";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptostreptococcus_anaerobius_vpi4330_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptostreptococcus_anaerobius_vpi4330_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptostreptococcus_anaerobius_vpi4330_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptostreptococcus_anaerobius_vpi4330_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1035196"]),
        None,
        Some("."),
        Some("HMPREF9998_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. F0040 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1035197.HMPREF9999_00001";
/// let this_library_node_name2 = "1035197.HMPREF9999_02367";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_f0040_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_f0040_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_f0040_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_f0040_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1035197"]),
        None,
        Some("."),
        Some("HMPREF9999_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dehalobacter sp. FTH1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1035308.AQYY01000001_gene1199";
/// let this_library_node_name2 = "1035308.AQYY01000021_gene23";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dehalobacter_sp_fth1_node_name(this_library_node_name1));
/// assert!(is_valid_string_dehalobacter_sp_fth1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dehalobacter_sp_fth1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dehalobacter_sp_fth1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1035308"]),
        None,
        Some("."),
        Some("AQYY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haemophilus sputorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1035839.AFNK01000001_gene345";
/// let this_library_node_name2 = "1035839.AFNK01000087_gene520";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haemophilus_sputorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_haemophilus_sputorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haemophilus_sputorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haemophilus_sputorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1035839"]),
        None,
        Some("."),
        Some("AFNK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Idiomarina sp. A28L nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1036674.A28LD_0001";
/// let this_library_node_name2 = "1036674.A28LD_2357";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_idiomarina_sp_a28l_node_name(this_library_node_name1));
/// assert!(is_valid_string_idiomarina_sp_a28l_node_name(this_library_node_name2));
/// assert!(!is_valid_string_idiomarina_sp_a28l_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_idiomarina_sp_a28l_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1036674"]),
        None,
        Some("."),
        Some("A28LD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium japonicum USDA6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1037409.BJ6T_00010";
/// let this_library_node_name2 = "1037409.BJ6T_88880";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_japonicum_usda6_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_japonicum_usda6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_japonicum_usda6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_japonicum_usda6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1037409"]),
        None,
        Some("."),
        Some("BJ6T_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma columbinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1037410.MCSF7_00005";
/// let this_library_node_name2 = "1037410.MCSF7_03198";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_columbinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_columbinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_columbinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_columbinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1037410"]),
        None,
        Some("."),
        Some("MCSF7_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Azorhizobium doebereinerae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1038858.AXBA01000001_gene3092";
/// let this_library_node_name2 = "1038858.AXBA01000107_gene5130";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_azorhizobium_doebereinerae_node_name(this_library_node_name1));
/// assert!(is_valid_string_azorhizobium_doebereinerae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_azorhizobium_doebereinerae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_azorhizobium_doebereinerae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1038858"]),
        None,
        Some("."),
        Some("AXBA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium elkanii WSM1741 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1038859.AXAU01000001_gene2596";
/// let this_library_node_name2 = "1038859.AXAU01000070_gene6787";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_elkanii_wsm1741_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_elkanii_wsm1741_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_elkanii_wsm1741_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_elkanii_wsm1741_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1038859"]),
        None,
        Some("."),
        Some("AXAU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium elkanii WSM2783 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1038860.AXAP01000001_gene6280";
/// let this_library_node_name2 = "1038860.AXAP01000218_gene2826";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_elkanii_wsm2783_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_elkanii_wsm2783_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_elkanii_wsm2783_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_elkanii_wsm2783_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1038860"]),
        None,
        Some("."),
        Some("AXAP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium japonicum USDA124 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1038862.KB893805_gene3366";
/// let this_library_node_name2 = "1038862.KB893927_gene1316";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_japonicum_usda124_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_japonicum_usda124_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_japonicum_usda124_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_japonicum_usda124_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1038862"]),
        None,
        Some("."),
        Some("KB893"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. WSM2793 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1038866.KB902768_gene4740";
/// let this_library_node_name2 = "1038866.KB902851_gene388";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_wsm2793_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_wsm2793_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_wsm2793_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_wsm2793_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1038866"]),
        None,
        Some("."),
        Some("KB902"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. WSM3983 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1038867.AXAY01000001_gene6224";
/// let this_library_node_name2 = "1038867.AXAY01000073_gene1914";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_wsm3983_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_wsm3983_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_wsm3983_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_wsm3983_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1038867"]),
        None,
        Some("."),
        Some("AXAY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia mimosarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1038869.AXAN01000001_gene3511";
/// let this_library_node_name2 = "1038869.AXAN01000270_gene4593";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_mimosarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_mimosarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_mimosarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_mimosarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1038869"]),
        None,
        Some("."),
        Some("AXAN01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas fluorescens Q287 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1038922.PflQ2_0001";
/// let this_library_node_name2 = "1038922.PflQ2_5710";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_fluorescens_q287_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_fluorescens_q287_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_fluorescens_q287_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_fluorescens_q287_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1038922"]),
        None,
        Some("."),
        Some("PflQ2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium loti CJ3sym nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1040982.AXAL01000001_gene1511";
/// let this_library_node_name2 = "1040982.AXAL01000071_gene3708";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_loti_cj3sym_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_loti_cj3sym_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_loti_cj3sym_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_loti_cj3sym_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1040982"]),
        None,
        Some("."),
        Some("AXAL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium loti USDA3471 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1040983.AXAE01000001_gene2619";
/// let this_library_node_name2 = "1040983.AXAE01000055_gene136";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_loti_usda3471_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_loti_usda3471_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_loti_usda3471_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_loti_usda3471_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1040983"]),
        None,
        Some("."),
        Some("AXAE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium sp. WSM3224 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1040986.ATYO01000001_gene1497";
/// let this_library_node_name2 = "1040986.ATYO01000074_gene143";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_sp_wsm3224_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_sp_wsm3224_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_sp_wsm3224_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_sp_wsm3224_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1040986"]),
        None,
        Some("."),
        Some("ATYO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium sp. WSM3626 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1040987.AZUY01000001_gene2418";
/// let this_library_node_name2 = "1040987.AZUY01000107_gene5457";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_sp_wsm3626_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_sp_wsm3626_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_sp_wsm3626_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_sp_wsm3626_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1040987"]),
        None,
        Some("."),
        Some("AZUY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. ARR65 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1040989.AWZU01000001_gene5480";
/// let this_library_node_name2 = "1040989.AWZU01000139_gene1958";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_arr65_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_arr65_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_arr65_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_arr65_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1040989"]),
        None,
        Some("."),
        Some("AWZU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium gallicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041138.KB890221_gene1000";
/// let this_library_node_name2 = "1041138.KB890258_gene2913";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_gallicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_gallicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_gallicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_gallicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041138"]),
        None,
        Some("."),
        Some("KB8902"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium giardinii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041139.KB902578_gene5030";
/// let this_library_node_name2 = "1041139.KB902767_gene2050";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_giardinii_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_giardinii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_giardinii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_giardinii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041139"]),
        None,
        Some("."),
        Some("KB902"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium leguminosarum GB30 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041142.ATTP01000001_gene1793";
/// let this_library_node_name2 = "1041142.ATTP01000078_gene2894";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_leguminosarum_gb30_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_leguminosarum_gb30_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_leguminosarum_gb30_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_leguminosarum_gb30_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041142"]),
        None,
        Some("."),
        Some("ATTP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sullae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041146.ATZB01000001_gene4396";
/// let this_library_node_name2 = "1041146.ATZB01000118_gene224";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sullae_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sullae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sullae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sullae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041146"]),
        None,
        Some("."),
        Some("ATZB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium leucaenae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041147.AUFB01000001_gene4176";
/// let this_library_node_name2 = "1041147.AUFB01000099_gene3";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_leucaenae_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_leucaenae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_leucaenae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_leucaenae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041147"]),
        None,
        Some("."),
        Some("AUFB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ensifer sp. WSM1721 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041159.AZUW01000001_gene3115";
/// let this_library_node_name2 = "1041159.AZUW01000070_gene2721";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ensifer_sp_wsm1721_node_name(this_library_node_name1));
/// assert!(is_valid_string_ensifer_sp_wsm1721_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ensifer_sp_wsm1721_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ensifer_sp_wsm1721_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041159"]),
        None,
        Some("."),
        Some("AZUW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthromitus sp. SFBratYit nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041504.RATSFB_0001";
/// let this_library_node_name2 = "1041504.RATSFB_1346";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthromitus_sp_sfbratyit_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthromitus_sp_sfbratyit_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthromitus_sp_sfbratyit_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthromitus_sp_sfbratyit_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041504"]),
        None,
        Some("."),
        Some("RATSFB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium colombiense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041522.MCOL_V200005";
/// let this_library_node_name2 = "1041522.MCOL_V226617";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_colombiense_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_colombiense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_colombiense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_colombiense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041522"]),
        None,
        Some("."),
        Some("MCOL_V2"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wickerhamomyces ciferrii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041607.K0K697";
/// let this_library_node_name2 = "1041607.Q9UVC0";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wickerhamomyces_ciferrii_node_name(this_library_node_name1));
/// assert!(is_valid_string_wickerhamomyces_ciferrii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wickerhamomyces_ciferrii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wickerhamomyces_ciferrii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041607"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium columnare nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041826.FCOL_00005";
/// let this_library_node_name2 = "1041826.FCOL_13540";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_columnare_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_columnare_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_columnare_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_columnare_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041826"]),
        None,
        Some("."),
        Some("FCOL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanocella conradii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1041930.Mtc_0001";
/// let this_library_node_name2 = "1041930.Mtc_p13";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanocella_conradii_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanocella_conradii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanocella_conradii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanocella_conradii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1041930"]),
        None,
        Some("."),
        Some("Mtc_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. SY8519 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1042156.CXIVA_00010";
/// let this_library_node_name2 = "1042156.CXIVA_26170";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_sy8519_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_sy8519_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_sy8519_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_sy8519_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1042156"]),
        None,
        Some("."),
        Some("CXIVA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacillus laterosporus LMG15441 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1042163.BRLA_07p000010";
/// let this_library_node_name2 = "1042163.BRLA_c046640";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacillus_laterosporus_lmg15441_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacillus_laterosporus_lmg15441_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacillus_laterosporus_lmg15441_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacillus_laterosporus_lmg15441_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1042163"]),
        None,
        Some("."),
        Some("BRLA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas fluorescens HK44 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1042209.HK44_000005";
/// let this_library_node_name2 = "1042209.HK44_030070";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_fluorescens_hk44_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_fluorescens_hk44_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_fluorescens_hk44_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_fluorescens_hk44_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1042209"]),
        None,
        Some("."),
        Some("HK44_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. IBUN nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1042326.AZNV01000001_gene5244";
/// let this_library_node_name2 = "1042326.AZNV01000100_gene1313";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_ibun_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_ibun_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_ibun_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_ibun_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1042326"]),
        None,
        Some("."),
        Some("AZNV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacterium stanieri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1042375.AFPL01000004_gene575";
/// let this_library_node_name2 = "1042375.AFPL01000058_gene1463";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacterium_stanieri_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacterium_stanieri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacterium_stanieri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacterium_stanieri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1042375"]),
        None,
        Some("."),
        Some("AFPL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacteriaceae bacterium S85 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1042376.AFPK01000001_gene1807";
/// let this_library_node_name2 = "1042376.AFPK01000077_gene1367";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacteriaceae_bacterium_s85_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacteriaceae_bacterium_s85_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacteriaceae_bacterium_s85_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacteriaceae_bacterium_s85_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1042376"]),
        None,
        Some("."),
        Some("AFPK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbulbifer agarilyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1042377.AFPJ01000002_gene511";
/// let this_library_node_name2 = "1042377.AFPJ01000057_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbulbifer_agarilyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbulbifer_agarilyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbulbifer_agarilyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbulbifer_agarilyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1042377"]),
        None,
        Some("."),
        Some("AFPJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas putida S16 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1042876.PPS_0001";
/// let this_library_node_name2 = "1042876.PPS_5280";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_putida_s16_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_putida_s16_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_putida_s16_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_putida_s16_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1042876"]),
        None,
        Some("."),
        Some("PPS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermococcus sp. 4557 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1042877.GQS_00005";
/// let this_library_node_name2 = "1042877.GQS_10715";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermococcus_sp_4557_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermococcus_sp_4557_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermococcus_sp_4557_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermococcus_sp_4557_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1042877"]),
        None,
        Some("."),
        Some("GQS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serinicoccus profundi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1043205.AFYF01000001_gene100";
/// let this_library_node_name2 = "1043205.AFYF01000102_gene586";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serinicoccus_profundi_node_name(this_library_node_name1));
/// assert!(is_valid_string_serinicoccus_profundi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serinicoccus_profundi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serinicoccus_profundi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1043205"]),
        None,
        Some("."),
        Some("AFYF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysinimicrobium mangrovi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1043493.BBLU01000001_gene1000";
/// let this_library_node_name2 = "1043493.BBLU01000033_gene3";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysinimicrobium_mangrovi_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysinimicrobium_mangrovi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysinimicrobium_mangrovi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysinimicrobium_mangrovi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1043493"]),
        None,
        Some("."),
        Some("BBLU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oenococcus kitaharae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1045004.OKIT_0001";
/// let this_library_node_name2 = "1045004.OKIT_1884";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oenococcus_kitaharae_node_name(this_library_node_name1));
/// assert!(is_valid_string_oenococcus_kitaharae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oenococcus_kitaharae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oenococcus_kitaharae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1045004"]),
        None,
        Some("."),
        Some("OKIT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citricoccus sp. CH26A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1045009.AFXQ01000001_gene2113";
/// let this_library_node_name2 = "1045009.AFXQ01000066_gene2448";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citricoccus_sp_ch26a_node_name(this_library_node_name1));
/// assert!(is_valid_string_citricoccus_sp_ch26a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citricoccus_sp_ch26a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citricoccus_sp_ch26a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1045009"]),
        None,
        Some("."),
        Some("AFXQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Weissella koreensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1045854.WKK_00005";
/// let this_library_node_name2 = "1045854.WKK_06957";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_weissella_koreensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_weissella_koreensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_weissella_koreensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_weissella_koreensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1045854"]),
        None,
        Some("."),
        Some("WKK_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoxanthomonas spadix nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1045855.DSC_00005";
/// let this_library_node_name2 = "1045855.DSC_15790";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoxanthomonas_spadix_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoxanthomonas_spadix_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoxanthomonas_spadix_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoxanthomonas_spadix_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1045855"]),
        None,
        Some("."),
        Some("DSC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacter cloacae EcWSU1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1045856.EcWSU1_00001";
/// let this_library_node_name2 = "1045856.EcWSU1_A085";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacter_cloacae_ecwsu1_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacter_cloacae_ecwsu1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacter_cloacae_ecwsu1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacter_cloacae_ecwsu1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1045856"]),
        None,
        Some("."),
        Some("EcWSU1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachyspira intermedia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1045858.Bint_0001";
/// let this_library_node_name2 = "1045858.Bint_2911";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachyspira_intermedia_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachyspira_intermedia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachyspira_intermedia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachyspira_intermedia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1045858"]),
        None,
        Some("."),
        Some("Bint_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter lwoffii WJ10621 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1046625.AFQY01000001_gene1000";
/// let this_library_node_name2 = "1046625.AFQY01000008_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_lwoffii_wj10621_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_lwoffii_wj10621_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_lwoffii_wj10621_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_lwoffii_wj10621_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1046625"]),
        None,
        Some("."),
        Some("AFQY0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bizionia argentinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1046627.BZARG_1";
/// let this_library_node_name2 = "1046627.BZARG_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bizionia_argentinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bizionia_argentinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bizionia_argentinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bizionia_argentinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1046627"]),
        None,
        Some("."),
        Some("BZARG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus salivarius 57I nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1046629.Ssal_00001";
/// let this_library_node_name2 = "1046629.Ssal_02164";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_salivarius_57i_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_salivarius_57i_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_salivarius_57i_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_salivarius_57i_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1046629"]),
        None,
        Some("."),
        Some("Ssal_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gayadomonas joobiniege nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1046714.AMRX01000001_gene1209";
/// let this_library_node_name2 = "1046714.AMRX01000008_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gayadomonas_joobiniege_node_name(this_library_node_name1));
/// assert!(is_valid_string_gayadomonas_joobiniege_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gayadomonas_joobiniege_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gayadomonas_joobiniege_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1046714"]),
        None,
        Some("."),
        Some("AMRX0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter lipolyticus BF04CF4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1046724.KB889827_gene2596";
/// let this_library_node_name2 = "1046724.KB889962_gene2502";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_lipolyticus_bf04cf4_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_lipolyticus_bf04cf4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_lipolyticus_bf04cf4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_lipolyticus_bf04cf4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1046724"]),
        None,
        Some("."),
        Some("KB889"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aminicenantes bacterium AAA252A02 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1047013.AQSP01000001_gene2021";
/// let this_library_node_name2 = "1047013.AQSP01000144_gene931";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aminicenantes_bacterium_aaa252a02_node_name(this_library_node_name1));
/// assert!(is_valid_string_aminicenantes_bacterium_aaa252a02_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aminicenantes_bacterium_aaa252a02_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aminicenantes_bacterium_aaa252a02_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1047013"]),
        None,
        Some("."),
        Some("AQSP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zymoseptoria tritici nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1047171.Mycgr3P100000";
/// let this_library_node_name2 = "1047171.Mycgr3P99982";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zymoseptoria_tritici_node_name(this_library_node_name1));
/// assert!(is_valid_string_zymoseptoria_tritici_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zymoseptoria_tritici_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zymoseptoria_tritici_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1047171"]),
        None,
        Some("."),
        Some("Mycgr3P"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporichthya polymorpha nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1048339.KB913029_gene1";
/// let this_library_node_name2 = "1048339.KB913029_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporichthya_polymorpha_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporichthya_polymorpha_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporichthya_polymorpha_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporichthya_polymorpha_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1048339"]),
        None,
        Some("."),
        Some("KB913029_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccidioides sp. lutzii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1048829.XP_002788955.1";
/// let this_library_node_name2 = "1048829.XP_002798090.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccidioides_sp_lutzii_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccidioides_sp_lutzii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccidioides_sp_lutzii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccidioides_sp_lutzii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1048829"]),
        None,
        Some("."),
        Some("XP_0027"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma iowae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1048830.GUU_00005";
/// let this_library_node_name2 = "1048830.GUU_05033";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_iowae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_iowae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_iowae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_iowae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1048830"]),
        None,
        Some("."),
        Some("GUU_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alicyclobacillus acidocaldarius Tc41 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1048834.TC41_0001";
/// let this_library_node_name2 = "1048834.TC41_3311";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alicyclobacillus_acidocaldarius_tc41_node_name(this_library_node_name1));
/// assert!(is_valid_string_alicyclobacillus_acidocaldarius_tc41_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alicyclobacillus_acidocaldarius_tc41_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alicyclobacillus_acidocaldarius_tc41_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1048834"]),
        None,
        Some("."),
        Some("TC41_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anditalea andensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1048983.EL17_00015";
/// let this_library_node_name2 = "1048983.EL17_24215";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anditalea_andensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anditalea_andensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anditalea_andensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anditalea_andensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1048983"]),
        None,
        Some("."),
        Some("EL17_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING endosymbiont of Tevnia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1049564.TevJSym_aa00010";
/// let this_library_node_name2 = "1049564.TevJSym_el00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_endosymbiont_of_tevnia_node_name(this_library_node_name1));
/// assert!(is_valid_string_endosymbiont_of_tevnia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_endosymbiont_of_tevnia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_endosymbiont_of_tevnia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1049564"]),
        None,
        Some("."),
        Some("TevJSym_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Allobaculum stercoricanis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1050201.KB913034_gene1";
/// let this_library_node_name2 = "1050201.KB913034_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_allobaculum_stercoricanis_node_name(this_library_node_name1));
/// assert!(is_valid_string_allobaculum_stercoricanis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_allobaculum_stercoricanis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_allobaculum_stercoricanis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1050201"]),
        None,
        Some("."),
        Some("KB913034_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinopolyspora mortivallis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1050202.KB913024_gene1";
/// let this_library_node_name2 = "1050202.KB913024_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinopolyspora_mortivallis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinopolyspora_mortivallis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinopolyspora_mortivallis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinopolyspora_mortivallis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1050202"]),
        None,
        Some("."),
        Some("KB913024_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium acnes SK182BJCVI nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1051006.HMPREF1162_0003";
/// let this_library_node_name2 = "1051006.HMPREF1162_2363";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_acnes_sk182bjcvi_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_acnes_sk182bjcvi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_acnes_sk182bjcvi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_acnes_sk182bjcvi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1051006"]),
        None,
        Some("."),
        Some("HMPREF1162_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus mojavensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1051501.AYTL01000001_gene221";
/// let this_library_node_name2 = "1051501.AYTL01000038_gene395";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_mojavensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_mojavensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_mojavensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_mojavensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1051501"]),
        None,
        Some("."),
        Some("AYTL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Verticillium alfalfae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1051613.XP_002999609.1";
/// let this_library_node_name2 = "1051613.XP_003009845.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_verticillium_alfalfae_node_name(this_library_node_name1));
/// assert!(is_valid_string_verticillium_alfalfae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_verticillium_alfalfae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_verticillium_alfalfae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1051613"]),
        None,
        Some("."),
        Some("XP_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfobacillus acidophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1051632.TPY_0001";
/// let this_library_node_name2 = "1051632.TPY_3830";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfobacillus_acidophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfobacillus_acidophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfobacillus_acidophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfobacillus_acidophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1051632"]),
        None,
        Some("."),
        Some("TPY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio tubiashii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1051646.VITU9109_00005";
/// let this_library_node_name2 = "1051646.VITU9109_26503";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_tubiashii_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_tubiashii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_tubiashii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_tubiashii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1051646"]),
        None,
        Some("."),
        Some("VITU9109_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neisseria weaveri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1051985.l11_00010";
/// let this_library_node_name2 = "1051985.l11_22440";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neisseria_weaveri_node_name(this_library_node_name1));
/// assert!(is_valid_string_neisseria_weaveri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neisseria_weaveri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neisseria_weaveri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1051985"]),
        None,
        Some("."),
        Some("l11_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus polymyxa M1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1052684.PPM_0001";
/// let this_library_node_name2 = "1052684.PPM_5071";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_polymyxa_m1_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_polymyxa_m1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_polymyxa_m1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_polymyxa_m1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1052684"]),
        None,
        Some("."),
        Some("PPM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetobacteraceae bacterium AT5844 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1054213.HMPREF9946_00001";
/// let this_library_node_name2 = "1054213.HMPREF9946_05337";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetobacteraceae_bacterium_at5844_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetobacteraceae_bacterium_at5844_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetobacteraceae_bacterium_at5844_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetobacteraceae_bacterium_at5844_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1054213"]),
        None,
        Some("."),
        Some("HMPREF9946_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoplasmatales archaeon nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1054217.TALC_00001";
/// let this_library_node_name2 = "1054217.TALC_01577";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoplasmatales_archaeon_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoplasmatales_archaeon_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoplasmatales_archaeon_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoplasmatales_archaeon_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1054217"]),
        None,
        Some("."),
        Some("TALC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus pseudopneumoniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1054460.SPPN_00005";
/// let this_library_node_name2 = "1054460.SPPN_11508";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_pseudopneumoniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_pseudopneumoniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_pseudopneumoniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_pseudopneumoniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1054460"]),
        None,
        Some("."),
        Some("SPPN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces purpureus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1054860.KB913030_gene1";
/// let this_library_node_name2 = "1054860.KB913030_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_purpureus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_purpureus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_purpureus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_purpureus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1054860"]),
        None,
        Some("."),
        Some("KB913030_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter sp. TB67 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1055815.AYYA01000001_gene1746";
/// let this_library_node_name2 = "1055815.AYYA01000086_gene2725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_sp_tb67_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_sp_tb67_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_sp_tb67_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_sp_tb67_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1055815"]),
        None,
        Some("."),
        Some("AYYA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldisphaera lagunensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1056495.Calag_0001";
/// let this_library_node_name2 = "1056495.Calag_1576";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldisphaera_lagunensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldisphaera_lagunensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldisphaera_lagunensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldisphaera_lagunensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1056495"]),
        None,
        Some("."),
        Some("Calag_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Grimontia indica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1056512.D515_00001";
/// let this_library_node_name2 = "1056512.D515_04987";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_grimontia_indica_node_name(this_library_node_name1));
/// assert!(is_valid_string_grimontia_indica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_grimontia_indica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_grimontia_indica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1056512"]),
        None,
        Some("."),
        Some("D515_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia sp. BMG51109 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1056816.JAFQ01000001_gene7373";
/// let this_library_node_name2 = "1056816.JAFQ01000004_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_sp_bmg51109_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_sp_bmg51109_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_sp_bmg51109_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_sp_bmg51109_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1056816"]),
        None,
        Some("."),
        Some("JAFQ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Teredinibacter turnerae T7902 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1056820.KB900629_gene1590";
/// let this_library_node_name2 = "1056820.KB900700_gene1190";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_teredinibacter_turnerae_t7902_node_name(this_library_node_name1));
/// assert!(is_valid_string_teredinibacter_turnerae_t7902_node_name(this_library_node_name2));
/// assert!(!is_valid_string_teredinibacter_turnerae_t7902_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_teredinibacter_turnerae_t7902_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1056820"]),
        None,
        Some("."),
        Some("KB900"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ensifer sp. BR816 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1057002.KB905370_gene1000";
/// let this_library_node_name2 = "1057002.KB905372_gene6114";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ensifer_sp_br816_node_name(this_library_node_name1));
/// assert!(is_valid_string_ensifer_sp_br816_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ensifer_sp_br816_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ensifer_sp_br816_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1057002"]),
        None,
        Some("."),
        Some("KB90537"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Megasphaera elsdenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1064535.MELS_0001";
/// let this_library_node_name2 = "1064535.MELS_2228";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_megasphaera_elsdenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_megasphaera_elsdenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_megasphaera_elsdenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_megasphaera_elsdenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1064535"]),
        None,
        Some("."),
        Some("MELS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachybacterium paraconglomeratum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1064537.AGSO01000001_gene421";
/// let this_library_node_name2 = "1064537.AGSO01000050_gene1329";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachybacterium_paraconglomeratum_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachybacterium_paraconglomeratum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachybacterium_paraconglomeratum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachybacterium_paraconglomeratum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1064537"]),
        None,
        Some("."),
        Some("AGSO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolatopsis methanolica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1068978.AMETH_0001";
/// let this_library_node_name2 = "1068978.AMETH_7074";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolatopsis_methanolica_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolatopsis_methanolica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolatopsis_methanolica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolatopsis_methanolica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1068978"]),
        None,
        Some("."),
        Some("AMETH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolatopsis nigrescens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1068980.ARVW01000001_gene1";
/// let this_library_node_name2 = "1068980.ARVW01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolatopsis_nigrescens_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolatopsis_nigrescens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolatopsis_nigrescens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolatopsis_nigrescens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1068980"]),
        None,
        Some("."),
        Some("ARVW01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Succinispira mobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1069080.KB913028_gene1";
/// let this_library_node_name2 = "1069080.KB913028_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_succinispira_mobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_succinispira_mobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_succinispira_mobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_succinispira_mobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1069080"]),
        None,
        Some("."),
        Some("KB913028_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus infantarius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1069533.Sinf_0001";
/// let this_library_node_name2 = "1069533.Sinf_1999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_infantarius_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_infantarius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_infantarius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_infantarius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1069533"]),
        None,
        Some("."),
        Some("Sinf_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus ruminis ATCC27782 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1069534.LRC_00010";
/// let this_library_node_name2 = "1069534.LRC_19820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_ruminis_atcc27782_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_ruminis_atcc27782_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_ruminis_atcc27782_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_ruminis_atcc27782_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1069534"]),
        None,
        Some("."),
        Some("LRC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glomeribacter gigasporarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1070319.CAGGBEG34_100002";
/// let this_library_node_name2 = "1070319.CAGGBEG34_990005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glomeribacter_gigasporarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_glomeribacter_gigasporarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glomeribacter_gigasporarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glomeribacter_gigasporarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1070319"]),
        None,
        Some("."),
        Some("CAGGBEG34_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halonotius sp. J07HN4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1070774.J07HN4v3_00001";
/// let this_library_node_name2 = "1070774.J07HN4v3_03284";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halonotius_sp_j07hn4_node_name(this_library_node_name1));
/// assert!(is_valid_string_halonotius_sp_j07hn4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halonotius_sp_j07hn4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halonotius_sp_j07hn4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1070774"]),
        None,
        Some("."),
        Some("J07HN4v3_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. NSP222 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1071073.KI530534_gene543";
/// let this_library_node_name2 = "1071073.KI530553_gene3803";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_nsp222_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_nsp222_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_nsp222_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_nsp222_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1071073"]),
        None,
        Some("."),
        Some("KI5305"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING haloarchaeon 3A1DGR nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1071085.KK033114_gene1";
/// let this_library_node_name2 = "1071085.KK033115_gene2665";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloarchaeon_3a1dgr_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloarchaeon_3a1dgr_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloarchaeon_3a1dgr_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloarchaeon_3a1dgr_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1071085"]),
        None,
        Some("."),
        Some("KK03311"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tetrapisispora blattae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1071379.XP_004177332.1";
/// let this_library_node_name2 = "1071379.XP_004182720.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tetrapisispora_blattae_node_name(this_library_node_name1));
/// assert!(is_valid_string_tetrapisispora_blattae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tetrapisispora_blattae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tetrapisispora_blattae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1071379"]),
        None,
        Some("."),
        Some("XP_0041"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus buchneri CD034 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1071400.347309351";
/// let this_library_node_name2 = "1071400.LBUCD034_2468";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_buchneri_cd034_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_buchneri_cd034_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_buchneri_cd034_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_buchneri_cd034_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1071400"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia grimmiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1071679.BG57_00015";
/// let this_library_node_name2 = "1071679.BG57_33135";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_grimmiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_grimmiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_grimmiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_grimmiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1071679"]),
        None,
        Some("."),
        Some("BG57_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Basilea psittacipulmonis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1072685.IX83_00005";
/// let this_library_node_name2 = "1072685.IX83_08750";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_basilea_psittacipulmonis_node_name(this_library_node_name1));
/// assert!(is_valid_string_basilea_psittacipulmonis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_basilea_psittacipulmonis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_basilea_psittacipulmonis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1072685"]),
        None,
        Some("."),
        Some("IX83_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cronobacter condimenti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1073999.BN137_1";
/// let this_library_node_name2 = "1073999.BN137_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cronobacter_condimenti_node_name(this_library_node_name1));
/// assert!(is_valid_string_cronobacter_condimenti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cronobacter_condimenti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cronobacter_condimenti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1073999"]),
        None,
        Some("."),
        Some("BN137_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus curvatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1074451.CRL705_1";
/// let this_library_node_name2 = "1074451.CRL705_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_curvatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_curvatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_curvatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_curvatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1074451"]),
        None,
        Some("."),
        Some("CRL705_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachybacterium squillarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1074488.AGBX01000001_gene1000";
/// let this_library_node_name2 = "1074488.AGBX01000008_gene2606";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachybacterium_squillarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachybacterium_squillarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachybacterium_squillarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachybacterium_squillarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1074488"]),
        None,
        Some("."),
        Some("AGBX0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blattabacterium sp. MADAR nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1074889.MADAR_001";
/// let this_library_node_name2 = "1074889.MADAR_p004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blattabacterium_sp_madar_node_name(this_library_node_name1));
/// assert!(is_valid_string_blattabacterium_sp_madar_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blattabacterium_sp_madar_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blattabacterium_sp_madar_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1074889"]),
        None,
        Some("."),
        Some("MADAR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia amarae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1075090.GOAMR_01_00020";
/// let this_library_node_name2 = "1075090.GOAMR_82_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_amarae_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_amarae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_amarae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_amarae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1075090"]),
        None,
        Some("."),
        Some("GOAMR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blattabacterium sp. Cpu nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1075399.BLBCPU_001";
/// let this_library_node_name2 = "1075399.BLBCPU_p004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blattabacterium_sp_cpu_node_name(this_library_node_name1));
/// assert!(is_valid_string_blattabacterium_sp_cpu_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blattabacterium_sp_cpu_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blattabacterium_sp_cpu_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1075399"]),
        None,
        Some("."),
        Some("BLBCPU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea rwandensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1076550.LH22_00020";
/// let this_library_node_name2 = "1076550.LH22_20470";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_rwandensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_rwandensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_rwandensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_rwandensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1076550"]),
        None,
        Some("."),
        Some("LH22_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dietzia alimentaria nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1077144.AGFF01000001_gene2503";
/// let this_library_node_name2 = "1077144.AGFF01000039_gene2518";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dietzia_alimentaria_node_name(this_library_node_name1));
/// assert!(is_valid_string_dietzia_alimentaria_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dietzia_alimentaria_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dietzia_alimentaria_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1077144"]),
        None,
        Some("."),
        Some("AGFF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides faecis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1077285.AGDG01000001_gene3237";
/// let this_library_node_name2 = "1077285.AGDG01000053_gene681";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_faecis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_faecis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_faecis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_faecis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1077285"]),
        None,
        Some("."),
        Some("AGDG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter globiformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1077972.ARGLB_001_00010";
/// let this_library_node_name2 = "1077972.ARGLB_125_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_globiformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_globiformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_globiformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_globiformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1077972"]),
        None,
        Some("."),
        Some("ARGLB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia effusa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1077974.GOEFS_001_00010";
/// let this_library_node_name2 = "1077974.GOEFS_132_01060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_effusa_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_effusa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_effusa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_effusa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1077974"]),
        None,
        Some("."),
        Some("GOEFS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium thermoresistibile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1078020.KEK_00005";
/// let this_library_node_name2 = "1078020.KEK_23361";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_thermoresistibile_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_thermoresistibile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_thermoresistibile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_thermoresistibile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1078020"]),
        None,
        Some("."),
        Some("KEK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus sp. HGB0015 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1078083.HMPREF1208_00005";
/// let this_library_node_name2 = "1078083.HMPREF1208_02357";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_sp_hgb0015_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_sp_hgb0015_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_sp_hgb0015_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_sp_hgb0015_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1078083"]),
        None,
        Some("."),
        Some("HMPREF1208_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenisporosarcina sp. HGH0030 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1078085.HMPREF1210_00020";
/// let this_library_node_name2 = "1078085.HMPREF1210_03519";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenisporosarcina_sp_hgh0030_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenisporosarcina_sp_hgh0030_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenisporosarcina_sp_hgh0030_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenisporosarcina_sp_hgh0030_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1078085"]),
        None,
        Some("."),
        Some("HMPREF1210_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium mongolense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1079460.ATTQ01000001_gene5456";
/// let this_library_node_name2 = "1079460.ATTQ01000096_gene6257";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_mongolense_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_mongolense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_mongolense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_mongolense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1079460"]),
        None,
        Some("."),
        Some("ATTQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces chartreusis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1079986.JH164837_gene5384";
/// let this_library_node_name2 = "1079986.JH164923_gene5383";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_chartreusis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_chartreusis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_chartreusis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_chartreusis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1079986"]),
        None,
        Some("."),
        Some("JH164"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citrobacter sp. S77 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1080067.BAZH01000001_gene3560";
/// let this_library_node_name2 = "1080067.BAZH01000066_gene3566";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citrobacter_sp_s77_node_name(this_library_node_name1));
/// assert!(is_valid_string_citrobacter_sp_s77_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citrobacter_sp_s77_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citrobacter_sp_s77_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1080067"]),
        None,
        Some("."),
        Some("BAZH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas elodea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1081640.AGFU01000001_gene476";
/// let this_library_node_name2 = "1081640.AGFU01000127_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_elodea_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_elodea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_elodea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_elodea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1081640"]),
        None,
        Some("."),
        Some("AGFU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquiluna sp. IMCC13023 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1081644.IMCC13023_00010";
/// let this_library_node_name2 = "1081644.IMCC13023_13650";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquiluna_sp_imcc13023_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquiluna_sp_imcc13023_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquiluna_sp_imcc13023_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquiluna_sp_imcc13023_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1081644"]),
        None,
        Some("."),
        Some("IMCC13023_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lonsdalea quercina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1082705.JIBP01000001_gene2840";
/// let this_library_node_name2 = "1082705.JIBP01000034_gene3071";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lonsdalea_quercina_node_name(this_library_node_name1));
/// assert!(is_valid_string_lonsdalea_quercina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lonsdalea_quercina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lonsdalea_quercina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1082705"]),
        None,
        Some("."),
        Some("JIBP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibacterium halotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1082931.KKY_1";
/// let this_library_node_name2 = "1082931.KKY_p3";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibacterium_halotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibacterium_halotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibacterium_halotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibacterium_halotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1082931"]),
        None,
        Some("."),
        Some("KKY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agrobacterium tumefaciens CCNWGS0286 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1082932.ATCR1_00005";
/// let this_library_node_name2 = "1082932.ATCR1_25095";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agrobacterium_tumefaciens_ccnwgs0286_node_name(this_library_node_name1));
/// assert!(is_valid_string_agrobacterium_tumefaciens_ccnwgs0286_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agrobacterium_tumefaciens_ccnwgs0286_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agrobacterium_tumefaciens_ccnwgs0286_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1082932"]),
        None,
        Some("."),
        Some("ATCR1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium amorphae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1082933.MEA186_00005";
/// let this_library_node_name2 = "1082933.MEA186_36049";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_amorphae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_amorphae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_amorphae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_amorphae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1082933"]),
        None,
        Some("."),
        Some("MEA186_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glaciecola nitratireducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1085623.GNIT_0001";
/// let this_library_node_name2 = "1085623.GNIT_3720";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glaciecola_nitratireducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_glaciecola_nitratireducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glaciecola_nitratireducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glaciecola_nitratireducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1085623"]),
        None,
        Some("."),
        Some("GNIT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium frigoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1086011.HJ01_00001";
/// let this_library_node_name2 = "1086011.HJ01_03590";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_frigoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_frigoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_frigoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_frigoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1086011"]),
        None,
        Some("."),
        Some("HJ01_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Exiguobacterium antarcticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1087448.Eab7_0001";
/// let this_library_node_name2 = "1087448.Eab7_2858";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_exiguobacterium_antarcticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_exiguobacterium_antarcticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_exiguobacterium_antarcticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_exiguobacterium_antarcticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1087448"]),
        None,
        Some("."),
        Some("Eab7_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus peoriae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1087481.AGFX01000001_gene127";
/// let this_library_node_name2 = "1087481.AGFX01000049_gene2598";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_peoriae_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_peoriae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_peoriae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_peoriae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1087481"]),
        None,
        Some("."),
        Some("AGFX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novosphingobium pentaromativorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1088721.NSU_0001";
/// let this_library_node_name2 = "1088721.NSU_pLA2087";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novosphingobium_pentaromativorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_novosphingobium_pentaromativorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novosphingobium_pentaromativorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novosphingobium_pentaromativorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1088721"]),
        None,
        Some("."),
        Some("NSU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Commensalibacter intestini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1088868.CIN_00010";
/// let this_library_node_name2 = "1088868.CIN_22100";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_commensalibacter_intestini_node_name(this_library_node_name1));
/// assert!(is_valid_string_commensalibacter_intestini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_commensalibacter_intestini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_commensalibacter_intestini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1088868"]),
        None,
        Some("."),
        Some("CIN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gluconobacter morbifer nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1088869.GMO_00010";
/// let this_library_node_name2 = "1088869.GMO_28520";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gluconobacter_morbifer_node_name(this_library_node_name1));
/// assert!(is_valid_string_gluconobacter_morbifer_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gluconobacter_morbifer_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gluconobacter_morbifer_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1088869"]),
        None,
        Some("."),
        Some("GMO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fangia hongkongensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089439.KB902239_gene372";
/// let this_library_node_name2 = "1089439.KB902275_gene1782";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fangia_hongkongensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_fangia_hongkongensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fangia_hongkongensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fangia_hongkongensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089439"]),
        None,
        Some("."),
        Some("KB9022"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aggregatibacter actinomycetemcomitans RhAA1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089447.RHAA1_00005";
/// let this_library_node_name2 = "1089447.RHAA1_10971";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aggregatibacter_actinomycetemcomitans_rhaa1_node_name(this_library_node_name1));
/// assert!(is_valid_string_aggregatibacter_actinomycetemcomitans_rhaa1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aggregatibacter_actinomycetemcomitans_rhaa1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aggregatibacter_actinomycetemcomitans_rhaa1_node_name(
    node_name: &str,
) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089447"]),
        None,
        Some("."),
        Some("RHAA1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia sputi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089453.GOSPT_001_00010";
/// let this_library_node_name2 = "1089453.GOSPT_160_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_sputi_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_sputi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_sputi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_sputi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089453"]),
        None,
        Some("."),
        Some("GOSPT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mobilicoccus pelagius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089455.MOPEL_001_00010";
/// let this_library_node_name2 = "1089455.MOPEL_138_00040";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mobilicoccus_pelagius_node_name(this_library_node_name1));
/// assert!(is_valid_string_mobilicoccus_pelagius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mobilicoccus_pelagius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mobilicoccus_pelagius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089455"]),
        None,
        Some("."),
        Some("MOPEL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolatopsis benzoatilytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089544.KB912942_gene1";
/// let this_library_node_name2 = "1089544.KB912942_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolatopsis_benzoatilytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolatopsis_benzoatilytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolatopsis_benzoatilytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolatopsis_benzoatilytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089544"]),
        None,
        Some("."),
        Some("KB912942_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolatopsis balhimycina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089545.KB913037_gene1";
/// let this_library_node_name2 = "1089545.KB913037_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolatopsis_balhimycina_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolatopsis_balhimycina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolatopsis_balhimycina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolatopsis_balhimycina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089545"]),
        None,
        Some("."),
        Some("KB913037_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinopolyspora halophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089546.AQUI01000001_gene1";
/// let this_library_node_name2 = "1089546.AQUI01000002_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinopolyspora_halophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinopolyspora_halophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinopolyspora_halophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinopolyspora_halophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089546"]),
        None,
        Some("."),
        Some("AQUI0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rudanella lutea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089547.KB913013_gene10";
/// let this_library_node_name2 = "1089547.KB913016_gene4813";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rudanella_lutea_node_name(this_library_node_name1));
/// assert!(is_valid_string_rudanella_lutea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rudanella_lutea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rudanella_lutea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089547"]),
        None,
        Some("."),
        Some("KB91301"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermicanus aegyptius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089548.KI783301_gene1";
/// let this_library_node_name2 = "1089548.KI783301_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermicanus_aegyptius_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermicanus_aegyptius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermicanus_aegyptius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermicanus_aegyptius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089548"]),
        None,
        Some("."),
        Some("KI783301_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloglycomyces albus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089549.AZUQ01000001_gene1";
/// let this_library_node_name2 = "1089549.AZUQ01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloglycomyces_albus_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloglycomyces_albus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloglycomyces_albus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloglycomyces_albus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089549"]),
        None,
        Some("."),
        Some("AZUQ01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salisaeta longa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089550.ATTH01000001_gene1000";
/// let this_library_node_name2 = "1089550.ATTH01000003_gene2589";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salisaeta_longa_node_name(this_library_node_name1));
/// assert!(is_valid_string_salisaeta_longa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salisaeta_longa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salisaeta_longa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089550"]),
        None,
        Some("."),
        Some("ATTH0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geminicoccus roseus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089551.KE386572_gene1";
/// let this_library_node_name2 = "1089551.KE386572_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geminicoccus_roseus_node_name(this_library_node_name1));
/// assert!(is_valid_string_geminicoccus_roseus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geminicoccus_roseus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geminicoccus_roseus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089551"]),
        None,
        Some("."),
        Some("KE386572_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodovibrio salinarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089552.KI911559_gene1";
/// let this_library_node_name2 = "1089552.KI911559_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodovibrio_salinarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodovibrio_salinarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodovibrio_salinarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodovibrio_salinarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089552"]),
        None,
        Some("."),
        Some("KI911559_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermacetogenium phaeum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1089553.Tph_c00010";
/// let this_library_node_name2 = "1089553.Tph_c29200";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermacetogenium_phaeum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermacetogenium_phaeum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermacetogenium_phaeum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermacetogenium_phaeum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1089553"]),
        None,
        Some("."),
        Some("Tph_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas phyllosphaerae 52 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1090318.ATTI01000001_gene100";
/// let this_library_node_name2 = "1090318.ATTI01000002_gene98";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_phyllosphaerae_52_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_phyllosphaerae_52_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_phyllosphaerae_52_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_phyllosphaerae_52_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1090318"]),
        None,
        Some("."),
        Some("ATTI0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas phyllosphaerae FA2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1090319.KE386571_gene1";
/// let this_library_node_name2 = "1090319.KE386571_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_phyllosphaerae_fa2_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_phyllosphaerae_fa2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_phyllosphaerae_fa2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_phyllosphaerae_fa2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1090319"]),
        None,
        Some("."),
        Some("KE386571_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas melonis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1090320.KB900605_gene1000";
/// let this_library_node_name2 = "1090320.KB900608_gene252";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_melonis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_melonis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_melonis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_melonis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1090320"]),
        None,
        Some("."),
        Some("KB90060"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas campestris musacearum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094184.KWO_0100010";
/// let this_library_node_name2 = "1094184.KWO_0122320";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_campestris_musacearum_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_campestris_musacearum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_campestris_musacearum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_campestris_musacearum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094184"]),
        None,
        Some("."),
        Some("KWO_01"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium indicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094466.KQS_00005";
/// let this_library_node_name2 = "1094466.KQS_13950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_indicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_indicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_indicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_indicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094466"]),
        None,
        Some("."),
        Some("KQS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella australis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094489.BAnh1_00010";
/// let this_library_node_name2 = "1094489.BAnh1_12910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_australis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_australis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_australis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_australis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094489"]),
        None,
        Some("."),
        Some("BAnh1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella bovis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094491.BBbe_00010";
/// let this_library_node_name2 = "1094491.BBbe_13300";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_bovis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_bovis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_bovis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_bovis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094491"]),
        None,
        Some("."),
        Some("BBbe_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella schoenbuchensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094496.m07a_00010";
/// let this_library_node_name2 = "1094496.m07a_pML00870";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_schoenbuchensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_schoenbuchensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_schoenbuchensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_schoenbuchensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094496"]),
        None,
        Some("."),
        Some("m07a_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella vinsonii berkhoffii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094497.BVwin_00010";
/// let this_library_node_name2 = "1094497.BVwin_15260";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_vinsonii_berkhoffii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_vinsonii_berkhoffii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_vinsonii_berkhoffii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_vinsonii_berkhoffii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094497"]),
        None,
        Some("."),
        Some("BVwin_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoanaerobacterium saccharolyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094508.Tsac_0001";
/// let this_library_node_name2 = "1094508.Tsac_2685";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoanaerobacterium_saccharolyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoanaerobacterium_saccharolyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoanaerobacterium_saccharolyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoanaerobacterium_saccharolyticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094508"]),
        None,
        Some("."),
        Some("Tsac_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella alsatica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094551.MEC_00001";
/// let this_library_node_name2 = "1094551.MEC_01370";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_alsatica_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_alsatica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_alsatica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_alsatica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094551"]),
        None,
        Some("."),
        Some("MEC_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella doshiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094553.MCS_00001";
/// let this_library_node_name2 = "1094553.MCS_01571";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_doshiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_doshiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_doshiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_doshiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094553"]),
        None,
        Some("."),
        Some("MCS_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella rattimassiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094556.MCY_00001";
/// let this_library_node_name2 = "1094556.MCY_01741";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_rattimassiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_rattimassiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_rattimassiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_rattimassiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094556"]),
        None,
        Some("."),
        Some("MCY_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella melophagi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094557.ME3_00001";
/// let this_library_node_name2 = "1094557.ME3_01338";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_melophagi_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_melophagi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_melophagi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_melophagi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094557"]),
        None,
        Some("."),
        Some("ME3_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella tamiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094558.ME5_00001";
/// let this_library_node_name2 = "1094558.ME5_01983";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_tamiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_tamiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_tamiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_tamiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094558"]),
        None,
        Some("."),
        Some("ME5_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella taylorii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094560.ME9_00001";
/// let this_library_node_name2 = "1094560.ME9_01726";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_taylorii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_taylorii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_taylorii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_taylorii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094560"]),
        None,
        Some("."),
        Some("ME9_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella vinsonii arupensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094561.MEI_00001";
/// let this_library_node_name2 = "1094561.MEI_01521";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_vinsonii_arupensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_vinsonii_arupensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_vinsonii_arupensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_vinsonii_arupensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094561"]),
        None,
        Some("."),
        Some("MEI_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella washoensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094563.MCQ_00001";
/// let this_library_node_name2 = "1094563.MCQ_01689";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_washoensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_washoensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_washoensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_washoensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094563"]),
        None,
        Some("."),
        Some("MCQ_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fluoribacter dumoffii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094715.CM001373_gene1000";
/// let this_library_node_name2 = "1094715.CM001375_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fluoribacter_dumoffii_node_name(this_library_node_name1));
/// assert!(is_valid_string_fluoribacter_dumoffii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fluoribacter_dumoffii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fluoribacter_dumoffii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094715"]),
        None,
        Some("."),
        Some("CM00137"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella sp. DB56 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094755.MCO_00001";
/// let this_library_node_name2 = "1094755.MCO_01943";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_sp_db56_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_sp_db56_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_sp_db56_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_sp_db56_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094755"]),
        None,
        Some("."),
        Some("MCO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanolobus psychrophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1094980.Mpsy_0001";
/// let this_library_node_name2 = "1094980.Mpsy_3181";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanolobus_psychrophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanolobus_psychrophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanolobus_psychrophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanolobus_psychrophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1094980"]),
        None,
        Some("."),
        Some("Mpsy_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. SK140 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095726.HMPREF1116_0001";
/// let this_library_node_name2 = "1095726.HMPREF1116_1907";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_sk140_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_sk140_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_sk140_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_sk140_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095726"]),
        None,
        Some("."),
        Some("HMPREF1116_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. SK643 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095727.HMPREF1117_0001";
/// let this_library_node_name2 = "1095727.HMPREF1117_1848";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_sk643_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_sk643_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_sk643_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_sk643_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095727"]),
        None,
        Some("."),
        Some("HMPREF1117_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mitis SK579 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095737.HMPREF1110_0001";
/// let this_library_node_name2 = "1095737.HMPREF1110_1969";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mitis_sk579_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mitis_sk579_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mitis_sk579_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mitis_sk579_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095737"]),
        None,
        Some("."),
        Some("HMPREF1110_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus oralis SK1074 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095738.HMPREF1047_0001";
/// let this_library_node_name2 = "1095738.HMPREF1047_1821";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_oralis_sk1074_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_oralis_sk1074_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_oralis_sk1074_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_oralis_sk1074_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095738"]),
        None,
        Some("."),
        Some("HMPREF1047_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haemophilus paraphrohaemolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095743.HMPREF1054_0001";
/// let this_library_node_name2 = "1095743.HMPREF1054_2087";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haemophilus_paraphrohaemolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_haemophilus_paraphrohaemolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haemophilus_paraphrohaemolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haemophilus_paraphrohaemolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095743"]),
        None,
        Some("."),
        Some("HMPREF1054_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium necrophorum funduliforme nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095747.HMPREF1049_0001";
/// let this_library_node_name2 = "1095747.HMPREF1049_2112";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_necrophorum_funduliforme_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_necrophorum_funduliforme_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_necrophorum_funduliforme_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_necrophorum_funduliforme_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095747"]),
        None,
        Some("."),
        Some("HMPREF1049_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pasteurella bettyae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095749.HMPREF1052_0001";
/// let this_library_node_name2 = "1095749.HMPREF1052_2244";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pasteurella_bettyae_node_name(this_library_node_name1));
/// assert!(is_valid_string_pasteurella_bettyae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pasteurella_bettyae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pasteurella_bettyae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095749"]),
        None,
        Some("."),
        Some("HMPREF1052_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnoanaerobaculum saburreum F0468 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095750.HMPREF9970_0002";
/// let this_library_node_name2 = "1095750.HMPREF9970_3081";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnoanaerobaculum_saburreum_f0468_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnoanaerobaculum_saburreum_f0468_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnoanaerobaculum_saburreum_f0468_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnoanaerobaculum_saburreum_f0468_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095750"]),
        None,
        Some("."),
        Some("HMPREF9970_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. F0472 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095752.HMPREF9969_0001";
/// let this_library_node_name2 = "1095752.HMPREF9969_2505";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_f0472_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_f0472_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_f0472_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_f0472_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095752"]),
        None,
        Some("."),
        Some("HMPREF9969_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellulomonas massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095767.CAHD01000001_gene2414";
/// let this_library_node_name2 = "1095767.CAHD01000250_gene485";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellulomonas_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellulomonas_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellulomonas_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellulomonas_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095767"]),
        None,
        Some("."),
        Some("CAHD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Herbaspirillum massiliense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095769.CAHF01000001_gene3427";
/// let this_library_node_name2 = "1095769.CAHF01000027_gene2743";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_herbaspirillum_massiliense_node_name(this_library_node_name1));
/// assert!(is_valid_string_herbaspirillum_massiliense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_herbaspirillum_massiliense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_herbaspirillum_massiliense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095769"]),
        None,
        Some("."),
        Some("CAHF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus timonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095770.CAHE01000001_gene1743";
/// let this_library_node_name2 = "1095770.CAHE01000100_gene254";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_timonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_timonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_timonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_timonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095770"]),
        None,
        Some("."),
        Some("CAHE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Timonella senegalensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1095772.CAHH01000001_gene786";
/// let this_library_node_name2 = "1095772.CAHH01000078_gene671";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_timonella_senegalensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_timonella_senegalensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_timonella_senegalensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_timonella_senegalensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1095772"]),
        None,
        Some("."),
        Some("CAHH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium sp. GXF4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1096546.WYO_0001";
/// let this_library_node_name2 = "1096546.WYO_5976";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_sp_gxf4_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_sp_gxf4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_sp_gxf4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_sp_gxf4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1096546"]),
        None,
        Some("."),
        Some("WYO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. PAO19 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1096756.ATKN01000001_gene1976";
/// let this_library_node_name2 = "1096756.ATKN01000043_gene3162";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_pao19_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_pao19_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_pao19_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_pao19_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1096756"]),
        None,
        Some("."),
        Some("ATKN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibacter ubique HIMB083 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1096769.Pelub83DRAFT_0001";
/// let this_library_node_name2 = "1096769.Pelub83DRAFT_1505";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibacter_ubique_himb083_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibacter_ubique_himb083_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibacter_ubique_himb083_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibacter_ubique_himb083_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1096769"]),
        None,
        Some("."),
        Some("Pelub83DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novosphingobium lindaniclasticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1096930.L284_00010";
/// let this_library_node_name2 = "1096930.L284_23485";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novosphingobium_lindaniclasticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_novosphingobium_lindaniclasticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novosphingobium_lindaniclasticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novosphingobium_lindaniclasticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1096930"]),
        None,
        Some("."),
        Some("L284_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sp. YI23 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1097668.BYI23_A000010";
/// let this_library_node_name2 = "1097668.BYI23_E003900";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sp_yi23_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sp_yi23_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sp_yi23_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sp_yi23_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1097668"]),
        None,
        Some("."),
        Some("BYI23_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Limnohabitans sp. Rim28 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1100720.ALKN01000001_gene1848";
/// let this_library_node_name2 = "1100720.ALKN01000068_gene1705";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_limnohabitans_sp_rim28_node_name(this_library_node_name1));
/// assert!(is_valid_string_limnohabitans_sp_rim28_node_name(this_library_node_name2));
/// assert!(!is_valid_string_limnohabitans_sp_rim28_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_limnohabitans_sp_rim28_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1100720"]),
        None,
        Some("."),
        Some("ALKN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Limnohabitans sp. Rim47 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1100721.ALKO01000002_gene2718";
/// let this_library_node_name2 = "1100721.ALKO01000214_gene75";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_limnohabitans_sp_rim47_node_name(this_library_node_name1));
/// assert!(is_valid_string_limnohabitans_sp_rim47_node_name(this_library_node_name2));
/// assert!(!is_valid_string_limnohabitans_sp_rim47_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_limnohabitans_sp_rim47_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1100721"]),
        None,
        Some("."),
        Some("ALKO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. MAN2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1101188.KI912155_gene1000";
/// let this_library_node_name2 = "1101188.KI912158_gene333";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_man2_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_man2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_man2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_man2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1101188"]),
        None,
        Some("."),
        Some("KI91215"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus sp. N5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1101189.AQUO01000001_gene1000";
/// let this_library_node_name2 = "1101189.AQUO01000003_gene3939";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_sp_n5_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_sp_n5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_sp_n5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_sp_n5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1101189"]),
        None,
        Some("."),
        Some("AQUO0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylopila sp. M107 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1101190.ARWB01000001_gene1";
/// let this_library_node_name2 = "1101190.ARWB01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylopila_sp_m107_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylopila_sp_m107_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylopila_sp_m107_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylopila_sp_m107_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1101190"]),
        None,
        Some("."),
        Some("ARWB01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium sp. 10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1101191.KI912577_gene1";
/// let this_library_node_name2 = "1101191.KI912577_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_sp_10_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_sp_10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_sp_10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_sp_10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1101191"]),
        None,
        Some("."),
        Some("KI912577_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium sp. 77 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1101192.KB910516_gene1";
/// let this_library_node_name2 = "1101192.KB910516_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_sp_77_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_sp_77_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_sp_77_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_sp_77_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1101192"]),
        None,
        Some("."),
        Some("KB910516_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylophilaceae bacterium 11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1101195.Meth11DRAFT_0001";
/// let this_library_node_name2 = "1101195.Meth11DRAFT_2657";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylophilaceae_bacterium_11_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylophilaceae_bacterium_11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylophilaceae_bacterium_11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylophilaceae_bacterium_11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1101195"]),
        None,
        Some("."),
        Some("Meth11DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrobaculum sp. 1860 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1104324.P186_0001";
/// let this_library_node_name2 = "1104324.P186_2921";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrobaculum_sp_1860_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrobaculum_sp_1860_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrobaculum_sp_1860_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrobaculum_sp_1860_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1104324"]),
        None,
        Some("."),
        Some("P186_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus faecium NRRLB2354 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1104325.M7W_1000";
/// let this_library_node_name2 = "1104325.M7W_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_faecium_nrrlb2354_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_faecium_nrrlb2354_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_faecium_nrrlb2354_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_faecium_nrrlb2354_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1104325"]),
        None,
        Some("."),
        Some("M7W_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. ICM39 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1105029.HMPREF1137_0001";
/// let this_library_node_name2 = "1105029.HMPREF1137_2014";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_icm39_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_icm39_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_icm39_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_icm39_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1105029"]),
        None,
        Some("."),
        Some("HMPREF1137_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. MSTE9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1105031.HMPREF1141_0001";
/// let this_library_node_name2 = "1105031.HMPREF1141_3572";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_mste9_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_mste9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_mste9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_mste9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1105031"]),
        None,
        Some("."),
        Some("HMPREF1141_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia australis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1105110.MC5_00005";
/// let this_library_node_name2 = "1105110.MC5_07300";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_australis_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_australis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_australis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_australis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1105110"]),
        None,
        Some("."),
        Some("MC5_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenirhodobacter enshiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1105367.CG50_00005";
/// let this_library_node_name2 = "1105367.CG50_16415";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenirhodobacter_enshiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenirhodobacter_enshiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenirhodobacter_enshiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenirhodobacter_enshiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1105367"]),
        None,
        Some("."),
        Some("CG50_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium enshiense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1107311.Q767_00005";
/// let this_library_node_name2 = "1107311.Q767_16075";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_enshiense_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_enshiense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_enshiense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_enshiense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1107311"]),
        None,
        Some("."),
        Some("Q767_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia rhizosphera nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1108045.GORHZ_001_00010";
/// let this_library_node_name2 = "1108045.GORHZ_261_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_rhizosphera_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_rhizosphera_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_rhizosphera_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_rhizosphera_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1108045"]),
        None,
        Some("."),
        Some("GORHZ_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Penicillium rubens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1108849.XP_002556565.1";
/// let this_library_node_name2 = "1108849.XP_002569355.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_penicillium_rubens_node_name(this_library_node_name1));
/// assert!(is_valid_string_penicillium_rubens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_penicillium_rubens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_penicillium_rubens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1108849"]),
        None,
        Some("."),
        Some("XP_0025"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas stutzeri SDMLAC nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1109445.AGSX01000002_gene746";
/// let this_library_node_name2 = "1109445.AGSX01000199_gene2958";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_stutzeri_sdmlac_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_stutzeri_sdmlac_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_stutzeri_sdmlac_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_stutzeri_sdmlac_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1109445"]),
        None,
        Some("."),
        Some("AGSX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tistrella mobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1110502.TMO_0001";
/// let this_library_node_name2 = "1110502.TMO_3565";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tistrella_mobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_tistrella_mobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tistrella_mobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tistrella_mobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1110502"]),
        None,
        Some("."),
        Some("TMO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia asteroides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1110697.NCAST_01_00010";
/// let this_library_node_name2 = "1110697.NCAST_38_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_asteroides_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_asteroides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_asteroides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_asteroides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1110697"]),
        None,
        Some("."),
        Some("NCAST_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus sp. CCBUS3UF1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111069.TCCBUS3UF1_10";
/// let this_library_node_name2 = "1111069.TCCBUS3UF1_p90";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_sp_ccbus3uf1_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_sp_ccbus3uf1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_sp_ccbus3uf1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_sp_ccbus3uf1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111069"]),
        None,
        Some("."),
        Some("TCCBUS3UF1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atopobium sp. BV3Ac4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111121.HMPREF1247_0001";
/// let this_library_node_name2 = "1111121.HMPREF1247_1639";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atopobium_sp_bv3ac4_node_name(this_library_node_name1));
/// assert!(is_valid_string_atopobium_sp_bv3ac4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atopobium_sp_bv3ac4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atopobium_sp_bv3ac4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111121"]),
        None,
        Some("."),
        Some("HMPREF1247_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionimicrobium sp. BV2F7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111131.HMPREF1255_0004";
/// let this_library_node_name2 = "1111131.HMPREF1255_1894";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionimicrobium_sp_bv2f7_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionimicrobium_sp_bv2f7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionimicrobium_sp_bv2f7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionimicrobium_sp_bv2f7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111131"]),
        None,
        Some("."),
        Some("HMPREF1255_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus sp. BV3C26 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111134.HMPREF1253_0001";
/// let this_library_node_name2 = "1111134.HMPREF1253_1995";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_sp_bv3c26_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_sp_bv3c26_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_sp_bv3c26_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_sp_bv3c26_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111134"]),
        None,
        Some("."),
        Some("HMPREF1253_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coriobacteriaceae bacterium BV3Ac1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111135.HMPREF1248_0001";
/// let this_library_node_name2 = "1111135.HMPREF1248_1666";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coriobacteriaceae_bacterium_bv3ac1_node_name(this_library_node_name1));
/// assert!(is_valid_string_coriobacteriaceae_bacterium_bv3ac1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coriobacteriaceae_bacterium_bv3ac1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coriobacteriaceae_bacterium_bv3ac1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111135"]),
        None,
        Some("."),
        Some("HMPREF1248_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Megasphaera sp. BV3C161 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111454.HMPREF1250_0001";
/// let this_library_node_name2 = "1111454.HMPREF1250_2282";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_megasphaera_sp_bv3c161_node_name(this_library_node_name1));
/// assert!(is_valid_string_megasphaera_sp_bv3c161_node_name(this_library_node_name2));
/// assert!(!is_valid_string_megasphaera_sp_bv3c161_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_megasphaera_sp_bv3c161_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111454"]),
        None,
        Some("."),
        Some("HMPREF1250_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alicyclobacillus pomorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111479.AXAR01000001_gene100";
/// let this_library_node_name2 = "1111479.AXAR01000036_gene3120";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alicyclobacillus_pomorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_alicyclobacillus_pomorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alicyclobacillus_pomorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alicyclobacillus_pomorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111479"]),
        None,
        Some("."),
        Some("AXAR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Budvicia aquatica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111728.ATYS01000001_gene2227";
/// let this_library_node_name2 = "1111728.ATYS01000130_gene3530";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_budvicia_aquatica_node_name(this_library_node_name1));
/// assert!(is_valid_string_budvicia_aquatica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_budvicia_aquatica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_budvicia_aquatica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111728"]),
        None,
        Some("."),
        Some("ATYS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium sputi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111729.ATYV01000001_gene2123";
/// let this_library_node_name2 = "1111729.ATYV01000040_gene798";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_sputi_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_sputi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_sputi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_sputi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111729"]),
        None,
        Some("."),
        Some("ATYV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium antarcticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111730.ATTM01000001_gene1297";
/// let this_library_node_name2 = "1111730.ATTM01000015_gene2745";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_antarcticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_antarcticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_antarcticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_antarcticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111730"]),
        None,
        Some("."),
        Some("ATTM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ignatzschineria larvae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1111732.AZOD01000001_gene1546";
/// let this_library_node_name2 = "1111732.AZOD01000056_gene1272";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ignatzschineria_larvae_node_name(this_library_node_name1));
/// assert!(is_valid_string_ignatzschineria_larvae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ignatzschineria_larvae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ignatzschineria_larvae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1111732"]),
        None,
        Some("."),
        Some("AZOD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia polyisoprenivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1112204.GPOL_174p00010";
/// let this_library_node_name2 = "1112204.GPOL_c50300";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_polyisoprenivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_polyisoprenivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_polyisoprenivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_polyisoprenivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1112204"]),
        None,
        Some("."),
        Some("GPOL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter sp. PAMC21119 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1112209.AHVZ01000001_gene1540";
/// let this_library_node_name2 = "1112209.AHVZ01000042_gene977";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_sp_pamc21119_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_sp_pamc21119_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_sp_pamc21119_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_sp_pamc21119_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1112209"]),
        None,
        Some("."),
        Some("AHVZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas echinoides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1112212.JH584235_gene1000";
/// let this_library_node_name2 = "1112212.JH584240_gene3857";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_echinoides_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_echinoides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_echinoides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_echinoides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1112212"]),
        None,
        Some("."),
        Some("JH5842"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. PAMC26605 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1112214.AHIS01000001_gene1727";
/// let this_library_node_name2 = "1112214.AHIS01000166_gene2206";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_pamc26605_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_pamc26605_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_pamc26605_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_pamc26605_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1112214"]),
        None,
        Some("."),
        Some("AHIS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. PAMC26617 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1112216.JH594425_gene100";
/// let this_library_node_name2 = "1112216.JH594434_gene44";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_pamc26617_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_pamc26617_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_pamc26617_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_pamc26617_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1112216"]),
        None,
        Some("."),
        Some("JH5944"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas psychrotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1112217.PPL19_00005";
/// let this_library_node_name2 = "1112217.PPL19_24046";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_psychrotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_psychrotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_psychrotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_psychrotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1112217"]),
        None,
        Some("."),
        Some("PPL19_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylophilus sp. 5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1112274.KI911560_gene1";
/// let this_library_node_name2 = "1112274.KI911560_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylophilus_sp_5_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylophilus_sp_5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylophilus_sp_5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylophilus_sp_5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1112274"]),
        None,
        Some("."),
        Some("KI911560_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natronorubrum tibetense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1114856.C496_00005";
/// let this_library_node_name2 = "1114856.C496_23723";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natronorubrum_tibetense_node_name(this_library_node_name1));
/// assert!(is_valid_string_natronorubrum_tibetense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natronorubrum_tibetense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natronorubrum_tibetense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1114856"]),
        None,
        Some("."),
        Some("C496_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citrobacter farmeri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1114922.CIFAM_01_00010";
/// let this_library_node_name2 = "1114922.CIFAM_31_00005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citrobacter_farmeri_node_name(this_library_node_name1));
/// assert!(is_valid_string_citrobacter_farmeri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citrobacter_farmeri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citrobacter_farmeri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1114922"]),
        None,
        Some("."),
        Some("CIFAM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharomonospora azurea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1114959.SZMC14600_00005";
/// let this_library_node_name2 = "1114959.SZMC14600_23525";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharomonospora_azurea_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharomonospora_azurea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharomonospora_azurea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharomonospora_azurea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1114959"]),
        None,
        Some("."),
        Some("SZMC14600_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium baderi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1114964.L485_00005";
/// let this_library_node_name2 = "1114964.L485_24860";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_baderi_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_baderi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_baderi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_baderi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1114964"]),
        None,
        Some("."),
        Some("L485_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus parasanguinis FW213 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1114965.Spaf_0001";
/// let this_library_node_name2 = "1114965.Spaf_igr1931";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_parasanguinis_fw213_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_parasanguinis_fw213_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_parasanguinis_fw213_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_parasanguinis_fw213_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1114965"]),
        None,
        Some("."),
        Some("Spaf_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas fluorescens F113 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1114970.PSF113_0001";
/// let this_library_node_name2 = "1114970.PSF113_5921";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_fluorescens_f113_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_fluorescens_f113_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_fluorescens_f113_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_fluorescens_f113_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1114970"]),
        None,
        Some("."),
        Some("PSF113_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus rossiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1114972.AUAW01000001_gene1303";
/// let this_library_node_name2 = "1114972.AUAW01000039_gene16";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_rossiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_rossiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_rossiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_rossiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1114972"]),
        None,
        Some("."),
        Some("AUAW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia hermannii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1115512.EH105704_01_00010";
/// let this_library_node_name2 = "1115512.EH105704_44_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_hermannii_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_hermannii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_hermannii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_hermannii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1115512"]),
        None,
        Some("."),
        Some("EH105704_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia vulneris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1115515.EV102420_01_00010";
/// let this_library_node_name2 = "1115515.EV102420_53_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_vulneris_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_vulneris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_vulneris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_vulneris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1115515"]),
        None,
        Some("."),
        Some("EV102420_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. 31Y nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1115632.JAFW01000001_gene1";
/// let this_library_node_name2 = "1115632.JAFW01000002_gene4703";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_31y_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_31y_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_31y_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_31y_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1115632"]),
        None,
        Some("."),
        Some("JAFW0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces naeslundii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1115803.HMPREF1129_0001";
/// let this_library_node_name2 = "1115803.HMPREF1129_2994";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_naeslundii_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_naeslundii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_naeslundii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_naeslundii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1115803"]),
        None,
        Some("."),
        Some("HMPREF1129_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus macedonicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1116231.SMA_0001";
/// let this_library_node_name2 = "1116231.SMA_p0017";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_macedonicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_macedonicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_macedonicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_macedonicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1116231"]),
        None,
        Some("."),
        Some("SMA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces acidiscabies nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1116232.AHBF01000001_gene5964";
/// let this_library_node_name2 = "1116232.AHBF01000244_gene7948";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_acidiscabies_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_acidiscabies_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_acidiscabies_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_acidiscabies_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1116232"]),
        None,
        Some("."),
        Some("AHBF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hoeflea sp. 108 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1116369.KB890024_gene1";
/// let this_library_node_name2 = "1116369.KB890028_gene4993";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hoeflea_sp_108_node_name(this_library_node_name1));
/// assert!(is_valid_string_hoeflea_sp_108_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hoeflea_sp_108_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hoeflea_sp_108_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1116369"]),
        None,
        Some("."),
        Some("KB89002"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio sp. EJY3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1116375.VEJY3_00005";
/// let this_library_node_name2 = "1116375.VEJY3_24381";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_sp_ejy3_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_sp_ejy3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_sp_ejy3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_sp_ejy3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1116375"]),
        None,
        Some("."),
        Some("VEJY3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methyloglobulus morosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1116472.MGMO_100c00010";
/// let this_library_node_name2 = "1116472.MGMO_9c00490";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methyloglobulus_morosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methyloglobulus_morosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methyloglobulus_morosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methyloglobulus_morosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1116472"]),
        None,
        Some("."),
        Some("MGMO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus alvei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1117108.PAALTS15_00015";
/// let this_library_node_name2 = "1117108.PAALTS15_29481";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_alvei_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_alvei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_alvei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_alvei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1117108"]),
        None,
        Some("."),
        Some("PAALTS15_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas citrea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1117314.PCIT_00005";
/// let this_library_node_name2 = "1117314.PCIT_22639";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_citrea_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_citrea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_citrea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_citrea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1117314"]),
        None,
        Some("."),
        Some("PCIT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas haloplanktis ATCC14393 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1117315.AHCA01000001_gene1858";
/// let this_library_node_name2 = "1117315.AHCA01000056_gene3937";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_haloplanktis_atcc14393_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_haloplanktis_atcc14393_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_haloplanktis_atcc14393_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_haloplanktis_atcc14393_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1117315"]),
        None,
        Some("."),
        Some("AHCA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas rubra nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1117318.PRUB_00005";
/// let this_library_node_name2 = "1117318.PRUB_25152";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_rubra_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_rubra_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_rubra_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_rubra_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1117318"]),
        None,
        Some("."),
        Some("PRUB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas spongiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1117319.PSPO_00005";
/// let this_library_node_name2 = "1117319.PSPO_21194";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_spongiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_spongiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_spongiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_spongiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1117319"]),
        None,
        Some("."),
        Some("PSPO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus bataviensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1117379.BABA_00005";
/// let this_library_node_name2 = "1117379.BABA_26283";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_bataviensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_bataviensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_bataviensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_bataviensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1117379"]),
        None,
        Some("."),
        Some("BABA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma canis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1117644.MCANPG14_00005";
/// let this_library_node_name2 = "1117644.MCANPG14_03410";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_canis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_canis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_canis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_canis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1117644"]),
        None,
        Some("."),
        Some("MCANPG14_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Simiduia agarivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1117647.M5M_00005";
/// let this_library_node_name2 = "1117647.M5M_19537";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_simiduia_agarivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_simiduia_agarivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_simiduia_agarivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_simiduia_agarivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1117647"]),
        None,
        Some("."),
        Some("M5M_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sinorhizobium fredii HH103 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1117943.SFHH103_00001";
/// let this_library_node_name2 = "1117943.SFHH103_04211";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sinorhizobium_fredii_hh103_node_name(this_library_node_name1));
/// assert!(is_valid_string_sinorhizobium_fredii_hh103_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sinorhizobium_fredii_hh103_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sinorhizobium_fredii_hh103_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1117943"]),
        None,
        Some("."),
        Some("SFHH103_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas extremaustralis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1117958.PE143B_0100005";
/// let this_library_node_name2 = "1117958.PE143B_0131080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_extremaustralis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_extremaustralis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_extremaustralis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_extremaustralis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1117958"]),
        None,
        Some("."),
        Some("PE143B_01"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacillus massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1118054.CAGW01000001_gene100";
/// let this_library_node_name2 = "1118054.CAGW01000131_gene4629";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacillus_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacillus_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacillus_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacillus_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1118054"]),
        None,
        Some("."),
        Some("CAGW01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerococcus sp. PH9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1118055.CAGU01000001_gene510";
/// let this_library_node_name2 = "1118055.CAGU01000085_gene366";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerococcus_sp_ph9_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerococcus_sp_ph9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerococcus_sp_ph9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerococcus_sp_ph9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1118055"]),
        None,
        Some("."),
        Some("CAGU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus grossensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1118057.CAGX01000001_gene255";
/// let this_library_node_name2 = "1118057.CAGX01000076_gene262";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_grossensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_grossensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_grossensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_grossensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1118057"]),
        None,
        Some("."),
        Some("CAGX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. ph3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1118058.CAGY01000001_gene1";
/// let this_library_node_name2 = "1118058.CAGY01000008_gene1582";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_ph3_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_ph3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_ph3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_ph3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1118058"]),
        None,
        Some("."),
        Some("CAGY0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kallipyga massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1118059.CAHC01000001_gene598";
/// let this_library_node_name2 = "1118059.CAHC01000022_gene597";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kallipyga_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_kallipyga_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kallipyga_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kallipyga_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1118059"]),
        None,
        Some("."),
        Some("CAHC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enorma massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1118060.CAGZ01000001_gene151";
/// let this_library_node_name2 = "1118060.CAGZ01000035_gene1283";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enorma_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_enorma_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enorma_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enorma_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1118060"]),
        None,
        Some("."),
        Some("CAGZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas sp. GFAJ1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1118153.MOY_00005";
/// let this_library_node_name2 = "1118153.MOY_16611";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_sp_gfaj1_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_sp_gfaj1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_sp_gfaj1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_sp_gfaj1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1118153"]),
        None,
        Some("."),
        Some("MOY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stenotrophomonas maltophilia PML168 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1118235.CAJH01000001_gene1";
/// let this_library_node_name2 = "1118235.CAJH01000097_gene3739";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stenotrophomonas_maltophilia_pml168_node_name(this_library_node_name1));
/// assert!(is_valid_string_stenotrophomonas_maltophilia_pml168_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stenotrophomonas_maltophilia_pml168_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stenotrophomonas_maltophilia_pml168_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1118235"]),
        None,
        Some("."),
        Some("CAJH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma hyorhinis SK76 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1118964.MOS_001";
/// let this_library_node_name2 = "1118964.MOS_786";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_hyorhinis_sk76_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_hyorhinis_sk76_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_hyorhinis_sk76_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_hyorhinis_sk76_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1118964"]),
        None,
        Some("."),
        Some("MOS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingopyxis sp. LC363 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120705.FG95_00001";
/// let this_library_node_name2 = "1120705.FG95_03959";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingopyxis_sp_lc363_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingopyxis_sp_lc363_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingopyxis_sp_lc363_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingopyxis_sp_lc363_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120705"]),
        None,
        Some("."),
        Some("FG95_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacterium sp. MS4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120746.CCNL01000001_gene1";
/// let this_library_node_name2 = "1120746.CCNL01000017_gene3299";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacterium_sp_ms4_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacterium_sp_ms4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacterium_sp_ms4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacterium_sp_ms4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120746"]),
        None,
        Some("."),
        Some("CCNL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylopila sp. 73B nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120792.JAFV01000001_gene1";
/// let this_library_node_name2 = "1120792.JAFV01000002_gene3948";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylopila_sp_73b_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylopila_sp_73b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylopila_sp_73b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylopila_sp_73b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120792"]),
        None,
        Some("."),
        Some("JAFV0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium sp. 141 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120797.KB908255_gene312";
/// let this_library_node_name2 = "1120797.KB908290_gene828";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_sp_141_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_sp_141_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_sp_141_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_sp_141_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120797"]),
        None,
        Some("."),
        Some("KB9082"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acaricomes phytoseiuli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120917.AQXM01000001_gene1277";
/// let this_library_node_name2 = "1120917.AQXM01000064_gene1505";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acaricomes_phytoseiuli_node_name(this_library_node_name1));
/// assert!(is_valid_string_acaricomes_phytoseiuli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acaricomes_phytoseiuli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acaricomes_phytoseiuli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120917"]),
        None,
        Some("."),
        Some("AQXM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetobacter nitrogenifigens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120919.AUBI01000001_gene2880";
/// let this_library_node_name2 = "1120919.AUBI01000052_gene1791";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetobacter_nitrogenifigens_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetobacter_nitrogenifigens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetobacter_nitrogenifigens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetobacter_nitrogenifigens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120919"]),
        None,
        Some("."),
        Some("AUBI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter bouvetii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120925.F941_00001";
/// let this_library_node_name2 = "1120925.F941_03209";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_bouvetii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_bouvetii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_bouvetii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_bouvetii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120925"]),
        None,
        Some("."),
        Some("F941_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobacillus capsulatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120931.KB893930_gene1401";
/// let this_library_node_name2 = "1120931.KB893975_gene1685";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobacillus_capsulatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobacillus_capsulatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobacillus_capsulatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobacillus_capsulatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120931"]),
        None,
        Some("."),
        Some("KB8939"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobaculum urinale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120933.ATUY01000001_gene691";
/// let this_library_node_name2 = "1120933.ATUY01000029_gene487";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobaculum_urinale_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobaculum_urinale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobaculum_urinale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobaculum_urinale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120933"]),
        None,
        Some("."),
        Some("ATUY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinokineospora enzanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120934.KB894403_gene1";
/// let this_library_node_name2 = "1120934.KB894490_gene2666";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinokineospora_enzanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinokineospora_enzanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinokineospora_enzanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinokineospora_enzanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120934"]),
        None,
        Some("."),
        Some("KB8944"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomadura atramentaria nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120936.KB907208_gene1000";
/// let this_library_node_name2 = "1120936.KB907244_gene3009";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomadura_atramentaria_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomadura_atramentaria_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomadura_atramentaria_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomadura_atramentaria_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120936"]),
        None,
        Some("."),
        Some("KB9072"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces dentalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120941.AUBL01000001_gene1354";
/// let this_library_node_name2 = "1120941.AUBL01000097_gene210";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_dentalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_dentalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_dentalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_dentalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120941"]),
        None,
        Some("."),
        Some("AUBL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces georgiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120942.AUBM01000001_gene1221";
/// let this_library_node_name2 = "1120942.AUBM01000027_gene1751";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_georgiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_georgiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_georgiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_georgiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120942"]),
        None,
        Some("."),
        Some("AUBM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces israelii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120944.JONS01000001_gene1856";
/// let this_library_node_name2 = "1120944.JONS01000104_gene1285";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_israelii_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_israelii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_israelii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_israelii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120944"]),
        None,
        Some("."),
        Some("JONS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces neuii DSM8576 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120945.ATUW01000001_gene1332";
/// let this_library_node_name2 = "1120945.ATUW01000029_gene1197";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_neuii_dsm8576_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_neuii_dsm8576_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_neuii_dsm8576_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_neuii_dsm8576_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120945"]),
        None,
        Some("."),
        Some("ATUW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces suimastitidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120946.AUBF01000001_gene123";
/// let this_library_node_name2 = "1120946.AUBF01000013_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_suimastitidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_suimastitidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_suimastitidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_suimastitidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120946"]),
        None,
        Some("."),
        Some("AUBF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces vaccimaxillae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120947.ATUX01000001_gene1998";
/// let this_library_node_name2 = "1120947.ATUX01000013_gene1176";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_vaccimaxillae_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_vaccimaxillae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_vaccimaxillae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_vaccimaxillae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120947"]),
        None,
        Some("."),
        Some("ATUX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomycetospora chiangmaiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120948.KB903217_gene1000";
/// let this_library_node_name2 = "1120948.KB903248_gene4406";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomycetospora_chiangmaiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomycetospora_chiangmaiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomycetospora_chiangmaiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomycetospora_chiangmaiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120948"]),
        None,
        Some("."),
        Some("KB9032"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinoplanes globisporus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120949.KB903294_gene3422";
/// let this_library_node_name2 = "1120949.KB903358_gene5322";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinoplanes_globisporus_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinoplanes_globisporus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinoplanes_globisporus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinoplanes_globisporus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120949"]),
        None,
        Some("."),
        Some("KB903"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinopolymorpha alba nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120950.KB892707_gene4562";
/// let this_library_node_name2 = "1120950.KB892833_gene4028";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinopolymorpha_alba_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinopolymorpha_alba_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinopolymorpha_alba_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinopolymorpha_alba_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120950"]),
        None,
        Some("."),
        Some("KB892"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aequorivita capsosiphonis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120951.AUBG01000001_gene1000";
/// let this_library_node_name2 = "1120951.AUBG01000030_gene1682";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aequorivita_capsosiphonis_node_name(this_library_node_name1));
/// assert!(is_valid_string_aequorivita_capsosiphonis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aequorivita_capsosiphonis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aequorivita_capsosiphonis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120951"]),
        None,
        Some("."),
        Some("AUBG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aestuariibacter salexigens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120953.AUBH01000001_gene1000";
/// let this_library_node_name2 = "1120953.AUBH01000023_gene2486";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aestuariibacter_salexigens_node_name(this_library_node_name1));
/// assert!(is_valid_string_aestuariibacter_salexigens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aestuariibacter_salexigens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aestuariibacter_salexigens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120953"]),
        None,
        Some("."),
        Some("AUBH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aestuariimicrobium kwangyangense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120954.ATXE01000001_gene1335";
/// let this_library_node_name2 = "1120954.ATXE01000004_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aestuariimicrobium_kwangyangense_node_name(this_library_node_name1));
/// assert!(is_valid_string_aestuariimicrobium_kwangyangense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aestuariimicrobium_kwangyangense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aestuariimicrobium_kwangyangense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120954"]),
        None,
        Some("."),
        Some("ATXE0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Afifella pfennigii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120956.JHZK01000001_gene3146";
/// let this_library_node_name2 = "1120956.JHZK01000059_gene1836";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_afifella_pfennigii_node_name(this_library_node_name1));
/// assert!(is_valid_string_afifella_pfennigii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_afifella_pfennigii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_afifella_pfennigii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120956"]),
        None,
        Some("."),
        Some("JHZK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agrococcus lahaulensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120958.AULD01000001_gene1";
/// let this_library_node_name2 = "1120958.AULD01000018_gene2541";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agrococcus_lahaulensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_agrococcus_lahaulensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agrococcus_lahaulensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agrococcus_lahaulensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120958"]),
        None,
        Some("."),
        Some("AULD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agromyces italicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120959.ATXF01000001_gene343";
/// let this_library_node_name2 = "1120959.ATXF01000012_gene3297";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agromyces_italicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_agromyces_italicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agromyces_italicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agromyces_italicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120959"]),
        None,
        Some("."),
        Some("ATXF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agromyces subbeticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120960.ATXG01000001_gene1000";
/// let this_library_node_name2 = "1120960.ATXG01000034_gene3830";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agromyces_subbeticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_agromyces_subbeticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agromyces_subbeticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agromyces_subbeticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120960"]),
        None,
        Some("."),
        Some("ATXG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Algicola sagamiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120963.KB894491_gene1000";
/// let this_library_node_name2 = "1120963.KB894527_gene598";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_algicola_sagamiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_algicola_sagamiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_algicola_sagamiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_algicola_sagamiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120963"]),
        None,
        Some("."),
        Some("KB894"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Algoriphagus mannitolivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120965.AUBV01000001_gene3138";
/// let this_library_node_name2 = "1120965.AUBV01000024_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_algoriphagus_mannitolivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_algoriphagus_mannitolivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_algoriphagus_mannitolivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_algoriphagus_mannitolivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120965"]),
        None,
        Some("."),
        Some("AUBV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Algoriphagus marincola DSM16067 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120966.AUBU01000001_gene1000";
/// let this_library_node_name2 = "1120966.AUBU01000034_gene513";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_algoriphagus_marincola_dsm16067_node_name(this_library_node_name1));
/// assert!(is_valid_string_algoriphagus_marincola_dsm16067_node_name(this_library_node_name2));
/// assert!(!is_valid_string_algoriphagus_marincola_dsm16067_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_algoriphagus_marincola_dsm16067_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120966"]),
        None,
        Some("."),
        Some("AUBU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Algoriphagus vanfongensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120968.AUBX01000001_gene2173";
/// let this_library_node_name2 = "1120968.AUBX01000018_gene2172";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_algoriphagus_vanfongensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_algoriphagus_vanfongensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_algoriphagus_vanfongensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_algoriphagus_vanfongensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120968"]),
        None,
        Some("."),
        Some("AUBX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aliagarivorans taiwanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120970.AUBZ01000001_gene3571";
/// let this_library_node_name2 = "1120970.AUBZ01000083_gene2317";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aliagarivorans_taiwanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_aliagarivorans_taiwanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aliagarivorans_taiwanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aliagarivorans_taiwanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120970"]),
        None,
        Some("."),
        Some("AUBZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alicyclobacillus contaminans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120971.AUCA01000001_gene1624";
/// let this_library_node_name2 = "1120971.AUCA01000108_gene602";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alicyclobacillus_contaminans_node_name(this_library_node_name1));
/// assert!(is_valid_string_alicyclobacillus_contaminans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alicyclobacillus_contaminans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alicyclobacillus_contaminans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120971"]),
        None,
        Some("."),
        Some("AUCA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alicyclobacillus herbarius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120972.AUMH01000001_gene1003";
/// let this_library_node_name2 = "1120972.AUMH01000058_gene1557";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alicyclobacillus_herbarius_node_name(this_library_node_name1));
/// assert!(is_valid_string_alicyclobacillus_herbarius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alicyclobacillus_herbarius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alicyclobacillus_herbarius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120972"]),
        None,
        Some("."),
        Some("AUMH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alicyclobacillus pohliae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120973.AQXL01000001_gene3021";
/// let this_library_node_name2 = "1120973.AQXL01000135_gene1492";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alicyclobacillus_pohliae_node_name(this_library_node_name1));
/// assert!(is_valid_string_alicyclobacillus_pohliae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alicyclobacillus_pohliae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alicyclobacillus_pohliae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120973"]),
        None,
        Some("."),
        Some("AQXL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alkanindiges illinoisensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120977.JHUX01000001_gene2653";
/// let this_library_node_name2 = "1120977.JHUX01000012_gene78";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alkanindiges_illinoisensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alkanindiges_illinoisensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alkanindiges_illinoisensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alkanindiges_illinoisensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120977"]),
        None,
        Some("."),
        Some("JHUX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Allofustis seminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120978.KB894079_gene518";
/// let this_library_node_name2 = "1120978.KB894092_gene1160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_allofustis_seminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_allofustis_seminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_allofustis_seminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_allofustis_seminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120978"]),
        None,
        Some("."),
        Some("KB8940"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alloscardovia omnicolens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120979.ATVB01000001_gene1";
/// let this_library_node_name2 = "1120979.ATVB01000043_gene1495";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alloscardovia_omnicolens_node_name(this_library_node_name1));
/// assert!(is_valid_string_alloscardovia_omnicolens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alloscardovia_omnicolens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alloscardovia_omnicolens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120979"]),
        None,
        Some("."),
        Some("ATVB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alysiella crassa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120980.JQKH01000001_gene614";
/// let this_library_node_name2 = "1120980.JQKH01000159_gene682";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alysiella_crassa_node_name(this_library_node_name1));
/// assert!(is_valid_string_alysiella_crassa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alysiella_crassa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alysiella_crassa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120980"]),
        None,
        Some("."),
        Some("JQKH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amorphus coralli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120983.KB894570_gene1174";
/// let this_library_node_name2 = "1120983.KB894579_gene1984";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amorphus_coralli_node_name(this_library_node_name1));
/// assert!(is_valid_string_amorphus_coralli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amorphus_coralli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amorphus_coralli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120983"]),
        None,
        Some("."),
        Some("KB89457"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaeroarcus burkinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120985.AUMI01000001_gene2069";
/// let this_library_node_name2 = "1120985.AUMI01000021_gene2850";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaeroarcus_burkinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaeroarcus_burkinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaeroarcus_burkinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaeroarcus_burkinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120985"]),
        None,
        Some("."),
        Some("AUMI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerobiospirillum succiniciproducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120988.AXWV01000001_gene293";
/// let this_library_node_name2 = "1120988.AXWV01000163_gene460";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerobiospirillum_succiniciproducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerobiospirillum_succiniciproducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerobiospirillum_succiniciproducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerobiospirillum_succiniciproducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120988"]),
        None,
        Some("."),
        Some("AXWV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerovorax odorimutans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120998.AUFC01000001_gene1706";
/// let this_library_node_name2 = "1120998.AUFC01000057_gene2330";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerovorax_odorimutans_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerovorax_odorimutans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerovorax_odorimutans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerovorax_odorimutans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120998"]),
        None,
        Some("."),
        Some("AUFC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Andreprevotia chitinilytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1120999.JONM01000001_gene1005";
/// let this_library_node_name2 = "1120999.JONM01000063_gene1561";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_andreprevotia_chitinilytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_andreprevotia_chitinilytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_andreprevotia_chitinilytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_andreprevotia_chitinilytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1120999"]),
        None,
        Some("."),
        Some("JONM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquaspirillum serpens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121004.ATVC01000001_gene338";
/// let this_library_node_name2 = "1121004.ATVC01000119_gene1502";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquaspirillum_serpens_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquaspirillum_serpens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquaspirillum_serpens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquaspirillum_serpens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121004"]),
        None,
        Some("."),
        Some("ATVC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquimarina muelleri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121007.AUML01000001_gene1233";
/// let this_library_node_name2 = "1121007.AUML01000106_gene3264";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquimarina_muelleri_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquimarina_muelleri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquimarina_muelleri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquimarina_muelleri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121007"]),
        None,
        Some("."),
        Some("AUML01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arenibacter certesii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121011.AUCB01000001_gene556";
/// let this_library_node_name2 = "1121011.AUCB01000087_gene2873";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arenibacter_certesii_node_name(this_library_node_name1));
/// assert!(is_valid_string_arenibacter_certesii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arenibacter_certesii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arenibacter_certesii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121011"]),
        None,
        Some("."),
        Some("AUCB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arenibacter latericius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121012.AUKX01000001_gene1162";
/// let this_library_node_name2 = "1121012.AUKX01000112_gene3762";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arenibacter_latericius_node_name(this_library_node_name1));
/// assert!(is_valid_string_arenibacter_latericius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arenibacter_latericius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arenibacter_latericius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121012"]),
        None,
        Some("."),
        Some("AUKX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arenimonas composti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121013.P873_00005";
/// let this_library_node_name2 = "1121013.P873_14655";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arenimonas_composti_node_name(this_library_node_name1));
/// assert!(is_valid_string_arenimonas_composti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arenimonas_composti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arenimonas_composti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121013"]),
        None,
        Some("."),
        Some("P873_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arenimonas oryziterrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121015.N789_00005";
/// let this_library_node_name2 = "1121015.N789_14815";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arenimonas_oryziterrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_arenimonas_oryziterrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arenimonas_oryziterrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arenimonas_oryziterrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121015"]),
        None,
        Some("."),
        Some("N789_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arsenicicoccus bolidensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121017.AUFG01000001_gene2879";
/// let this_library_node_name2 = "1121017.AUFG01000086_gene2050";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arsenicicoccus_bolidensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_arsenicicoccus_bolidensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arsenicicoccus_bolidensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arsenicicoccus_bolidensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121017"]),
        None,
        Some("."),
        Some("AUFG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter castelli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121019.AUMN01000001_gene447";
/// let this_library_node_name2 = "1121019.AUMN01000051_gene3306";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_castelli_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_castelli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_castelli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_castelli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121019"]),
        None,
        Some("."),
        Some("AUMN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sanguinis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121020.JIAG01000001_gene1000";
/// let this_library_node_name2 = "1121020.JIAG01000027_gene1257";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sanguinis_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sanguinis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sanguinis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sanguinis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121020"]),
        None,
        Some("."),
        Some("JIAG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Asticcacaulis benevestitus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121022.ABENE_00010";
/// let this_library_node_name2 = "1121022.ABENE_23840";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_asticcacaulis_benevestitus_node_name(this_library_node_name1));
/// assert!(is_valid_string_asticcacaulis_benevestitus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_asticcacaulis_benevestitus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_asticcacaulis_benevestitus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121022"]),
        None,
        Some("."),
        Some("ABENE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atopococcus tabaci nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121024.AUCD01000001_gene1633";
/// let this_library_node_name2 = "1121024.AUCD01000141_gene463";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atopococcus_tabaci_node_name(this_library_node_name1));
/// assert!(is_valid_string_atopococcus_tabaci_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atopococcus_tabaci_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atopococcus_tabaci_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121024"]),
        None,
        Some("."),
        Some("AUCD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aureimonas ureilytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121028.ARQE01000001_gene2987";
/// let this_library_node_name2 = "1121028.ARQE01000044_gene104";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aureimonas_ureilytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_aureimonas_ureilytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aureimonas_ureilytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aureimonas_ureilytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121028"]),
        None,
        Some("."),
        Some("ARQE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Azospirillum halopraeferens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121033.AUCF01000001_gene1881";
/// let this_library_node_name2 = "1121033.AUCF01000054_gene554";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_azospirillum_halopraeferens_node_name(this_library_node_name1));
/// assert!(is_valid_string_azospirillum_halopraeferens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_azospirillum_halopraeferens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_azospirillum_halopraeferens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121033"]),
        None,
        Some("."),
        Some("AUCF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Azovibrio restrictus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121035.AUCH01000001_gene1731";
/// let this_library_node_name2 = "1121035.AUCH01000054_gene1719";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_azovibrio_restrictus_node_name(this_library_node_name1));
/// assert!(is_valid_string_azovibrio_restrictus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_azovibrio_restrictus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_azovibrio_restrictus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121035"]),
        None,
        Some("."),
        Some("AUCH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus aidingensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121085.AUCI01000001_gene3425";
/// let this_library_node_name2 = "1121085.AUCI01000056_gene4275";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_aidingensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_aidingensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_aidingensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_aidingensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121085"]),
        None,
        Some("."),
        Some("AUCI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus chagannorensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121087.AUCK01000001_gene2592";
/// let this_library_node_name2 = "1121087.AUCK01000043_gene88";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_chagannorensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_chagannorensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_chagannorensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_chagannorensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121087"]),
        None,
        Some("."),
        Some("AUCK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus fordii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121090.KB894685_gene3383";
/// let this_library_node_name2 = "1121090.KB894729_gene1921";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_fordii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_fordii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_fordii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_fordii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121090"]),
        None,
        Some("."),
        Some("KB894"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus gelatini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121091.AUMP01000001_gene1";
/// let this_library_node_name2 = "1121091.AUMP01000080_gene2443";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_gelatini_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_gelatini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_gelatini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_gelatini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121091"]),
        None,
        Some("."),
        Some("AUMP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides barnesiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121094.KB894643_gene1645";
/// let this_library_node_name2 = "1121094.KB894683_gene1021";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_barnesiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_barnesiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_barnesiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_barnesiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121094"]),
        None,
        Some("."),
        Some("KB8946"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides graminisolvens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121097.JCM15093_10";
/// let this_library_node_name2 = "1121097.JCM15093_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_graminisolvens_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_graminisolvens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_graminisolvens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_graminisolvens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121097"]),
        None,
        Some("."),
        Some("JCM15093_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides massiliensis B84634 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121098.HMPREF1534_00001";
/// let this_library_node_name2 = "1121098.HMPREF1534_04014";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_massiliensis_b84634_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_massiliensis_b84634_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_massiliensis_b84634_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_massiliensis_b84634_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121098"]),
        None,
        Some("."),
        Some("HMPREF1534_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides pyogenes DSM20611 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121100.JCM6294_1";
/// let this_library_node_name2 = "1121100.JCM6294_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_pyogenes_dsm20611_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_pyogenes_dsm20611_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_pyogenes_dsm20611_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_pyogenes_dsm20611_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121100"]),
        None,
        Some("."),
        Some("JCM6294_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides salyersiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121101.HMPREF1532_00001";
/// let this_library_node_name2 = "1121101.HMPREF1532_04229";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_salyersiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_salyersiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_salyersiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_salyersiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121101"]),
        None,
        Some("."),
        Some("HMPREF1532_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Balneola vulgaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121104.AQXH01000001_gene1000";
/// let this_library_node_name2 = "1121104.AQXH01000018_gene810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_balneola_vulgaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_balneola_vulgaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_balneola_vulgaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_balneola_vulgaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121104"]),
        None,
        Some("."),
        Some("AQXH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bavariicoccus seileri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121105.ATXL01000001_gene190";
/// let this_library_node_name2 = "1121105.ATXL01000109_gene1466";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bavariicoccus_seileri_node_name(this_library_node_name1));
/// assert!(is_valid_string_bavariicoccus_seileri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bavariicoccus_seileri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bavariicoccus_seileri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121105"]),
        None,
        Some("."),
        Some("ATXL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Belnapia moabensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121106.JQKB01000001_gene3106";
/// let this_library_node_name2 = "1121106.JQKB01000288_gene4166";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_belnapia_moabensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_belnapia_moabensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_belnapia_moabensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_belnapia_moabensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121106"]),
        None,
        Some("."),
        Some("JQKB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blautia wexlerae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121115.AXVN01000001_gene1040";
/// let this_library_node_name2 = "1121115.AXVN01000210_gene191";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blautia_wexlerae_node_name(this_library_node_name1));
/// assert!(is_valid_string_blautia_wexlerae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blautia_wexlerae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blautia_wexlerae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121115"]),
        None,
        Some("."),
        Some("AXVN01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachymonas chironomi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121116.KB894765_gene1000";
/// let this_library_node_name2 = "1121116.KB894798_gene2294";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachymonas_chironomi_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachymonas_chironomi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachymonas_chironomi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachymonas_chironomi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121116"]),
        None,
        Some("."),
        Some("KB8947"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacillus laterosporus DSM25 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121121.KB894284_gene414";
/// let this_library_node_name2 = "1121121.KB894352_gene2071";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacillus_laterosporus_dsm25_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacillus_laterosporus_dsm25_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacillus_laterosporus_dsm25_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacillus_laterosporus_dsm25_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121121"]),
        None,
        Some("."),
        Some("KB894"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevundimonas aveniformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121123.AUAO01000001_gene1000";
/// let this_library_node_name2 = "1121123.AUAO01000007_gene2013";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevundimonas_aveniformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevundimonas_aveniformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevundimonas_aveniformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevundimonas_aveniformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121123"]),
        None,
        Some("."),
        Some("AUAO0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevundimonas bacteroides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121124.JNIX01000001_gene1000";
/// let this_library_node_name2 = "1121124.JNIX01000016_gene2183";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevundimonas_bacteroides_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevundimonas_bacteroides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevundimonas_bacteroides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevundimonas_bacteroides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121124"]),
        None,
        Some("."),
        Some("JNIX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia nodosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121127.JAFA01000001_gene1000";
/// let this_library_node_name2 = "1121127.JAFA01000115_gene7603";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_nodosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_nodosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_nodosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_nodosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121127"]),
        None,
        Some("."),
        Some("JAFA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyricimonas synergistica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121129.KB903359_gene1045";
/// let this_library_node_name2 = "1121129.KB903374_gene641";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyricimonas_synergistica_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyricimonas_synergistica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyricimonas_synergistica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyricimonas_synergistica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121129"]),
        None,
        Some("."),
        Some("KB9033"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter cuniculorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121267.JHZL01000001_gene549";
/// let this_library_node_name2 = "1121267.JHZL01000046_gene548";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_cuniculorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_cuniculorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_cuniculorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_cuniculorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121267"]),
        None,
        Some("."),
        Some("JHZL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemmobacter nectariphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121271.AUCM01000001_gene3312";
/// let this_library_node_name2 = "1121271.AUCM01000059_gene2676";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemmobacter_nectariphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemmobacter_nectariphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemmobacter_nectariphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemmobacter_nectariphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121271"]),
        None,
        Some("."),
        Some("AUCM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Catelliglobosispora koreensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121272.KB903249_gene1216";
/// let this_library_node_name2 = "1121272.KB903293_gene7412";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_catelliglobosispora_koreensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_catelliglobosispora_koreensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_catelliglobosispora_koreensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_catelliglobosispora_koreensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121272"]),
        None,
        Some("."),
        Some("KB9032"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium caeni nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121285.AUFK01000001_gene1957";
/// let this_library_node_name2 = "1121285.AUFK01000020_gene3385";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_caeni_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_caeni_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_caeni_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_caeni_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121285"]),
        None,
        Some("."),
        Some("AUFK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium daeguense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121286.AUMT01000001_gene1";
/// let this_library_node_name2 = "1121286.AUMT01000026_gene2889";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_daeguense_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_daeguense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_daeguense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_daeguense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121286"]),
        None,
        Some("."),
        Some("AUMT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium gregarium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121287.AUMU01000001_gene1237";
/// let this_library_node_name2 = "1121287.AUMU01000043_gene1721";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_gregarium_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_gregarium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_gregarium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_gregarium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121287"]),
        None,
        Some("."),
        Some("AUMU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium palustre nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121288.AULL01000001_gene2508";
/// let this_library_node_name2 = "1121288.AULL01000020_gene2604";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_palustre_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_palustre_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_palustre_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_palustre_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121288"]),
        None,
        Some("."),
        Some("AULL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiisalibacter paucivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121289.JHVL01000001_gene1826";
/// let this_library_node_name2 = "1121289.JHVL01000091_gene2470";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiisalibacter_paucivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiisalibacter_paucivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiisalibacter_paucivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiisalibacter_paucivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121289"]),
        None,
        Some("."),
        Some("JHVL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium aminophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121296.JONJ01000001_gene1534";
/// let this_library_node_name2 = "1121296.JONJ01000035_gene2133";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_aminophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_aminophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_aminophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_aminophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121296"]),
        None,
        Some("."),
        Some("JONJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium litorale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121324.CLIT_10c00020";
/// let this_library_node_name2 = "1121324.CLIT_8c01580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_litorale_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_litorale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_litorale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_litorale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121324"]),
        None,
        Some("."),
        Some("CLIT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium saccharogumia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121333.JMLH01000001_gene1841";
/// let this_library_node_name2 = "1121333.JMLH01000135_gene1599";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_saccharogumia_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_saccharogumia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_saccharogumia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_saccharogumia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121333"]),
        None,
        Some("."),
        Some("JMLH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sporosphaeroides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121334.KB911066_gene1000";
/// let this_library_node_name2 = "1121334.KB911084_gene487";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sporosphaeroides_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sporosphaeroides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sporosphaeroides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sporosphaeroides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121334"]),
        None,
        Some("."),
        Some("KB9110"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium stercorarium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121335.Clst_0001";
/// let this_library_node_name2 = "1121335.Clst_2668";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_stercorarium_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_stercorarium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_stercorarium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_stercorarium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121335"]),
        None,
        Some("."),
        Some("Clst_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium tyrobutyricum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121342.AUCO01000001_gene1952";
/// let this_library_node_name2 = "1121342.AUCO01000045_gene1121";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_tyrobutyricum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_tyrobutyricum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_tyrobutyricum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_tyrobutyricum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121342"]),
        None,
        Some("."),
        Some("AUCO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium viride nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121344.JHZO01000001_gene305";
/// let this_library_node_name2 = "1121344.JHZO01000008_gene1156";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_viride_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_viride_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_viride_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_viride_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121344"]),
        None,
        Some("."),
        Some("JHZO0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cohnella laeviribosi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121346.KB899808_gene3361";
/// let this_library_node_name2 = "1121346.KB899909_gene234";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cohnella_laeviribosi_node_name(this_library_node_name1));
/// assert!(is_valid_string_cohnella_laeviribosi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cohnella_laeviribosi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cohnella_laeviribosi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121346"]),
        None,
        Some("."),
        Some("KB899"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Conchiformibius kuhniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121351.AUAP01000001_gene551";
/// let this_library_node_name2 = "1121351.AUAP01000055_gene1843";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_conchiformibius_kuhniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_conchiformibius_kuhniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_conchiformibius_kuhniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_conchiformibius_kuhniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121351"]),
        None,
        Some("."),
        Some("AUAP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Conchiformibius steedae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121352.JHZP01000001_gene1";
/// let this_library_node_name2 = "1121352.JHZP01000026_gene1055";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_conchiformibius_steedae_node_name(this_library_node_name1));
/// assert!(is_valid_string_conchiformibius_steedae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_conchiformibius_steedae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_conchiformibius_steedae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121352"]),
        None,
        Some("."),
        Some("JHZP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium callunae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121353.H924_00005";
/// let this_library_node_name2 = "1121353.H924_13610";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_callunae_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_callunae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_callunae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_callunae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121353"]),
        None,
        Some("."),
        Some("H924_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium capitovis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121354.AQUV01000001_gene1218";
/// let this_library_node_name2 = "1121354.AQUV01000004_gene618";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_capitovis_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_capitovis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_capitovis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_capitovis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121354"]),
        None,
        Some("."),
        Some("AQUV0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium caspium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121355.KB903375_gene1216";
/// let this_library_node_name2 = "1121355.KB903381_gene627";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_caspium_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_caspium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_caspium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_caspium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121355"]),
        None,
        Some("."),
        Some("KB9033"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium ciconiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121356.AQUW01000001_gene1000";
/// let this_library_node_name2 = "1121356.AQUW01000022_gene783";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_ciconiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_ciconiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_ciconiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_ciconiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121356"]),
        None,
        Some("."),
        Some("AQUW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium freiburgense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121360.AUAQ01000001_gene2069";
/// let this_library_node_name2 = "1121360.AUAQ01000020_gene2571";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_freiburgense_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_freiburgense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_freiburgense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_freiburgense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121360"]),
        None,
        Some("."),
        Some("AUAQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium halotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121362.A605_00005";
/// let this_library_node_name2 = "1121362.A605_14567";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_halotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_halotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_halotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_halotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121362"]),
        None,
        Some("."),
        Some("A605_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium lubricantis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121363.KB902181_gene2189";
/// let this_library_node_name2 = "1121363.KB902238_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_lubricantis_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_lubricantis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_lubricantis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_lubricantis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121363"]),
        None,
        Some("."),
        Some("KB902"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium massiliense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121364.ATVG01000001_gene1000";
/// let this_library_node_name2 = "1121364.ATVG01000024_gene57";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_massiliense_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_massiliense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_massiliense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_massiliense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121364"]),
        None,
        Some("."),
        Some("ATVG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium mastitidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121365.AQXB01000001_gene1000";
/// let this_library_node_name2 = "1121365.AQXB01000030_gene1584";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_mastitidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_mastitidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_mastitidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_mastitidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121365"]),
        None,
        Some("."),
        Some("AQXB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium pilosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121366.KB892438_gene562";
/// let this_library_node_name2 = "1121366.KB892472_gene351";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_pilosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_pilosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_pilosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_pilosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121366"]),
        None,
        Some("."),
        Some("KB8924"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium propinquum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121367.AQXC01000001_gene1262";
/// let this_library_node_name2 = "1121367.AQXC01000022_gene167";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_propinquum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_propinquum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_propinquum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_propinquum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121367"]),
        None,
        Some("."),
        Some("AQXC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium ulceribovis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121370.AQUY01000001_gene1";
/// let this_library_node_name2 = "1121370.AQUY01000007_gene1483";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_ulceribovis_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_ulceribovis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_ulceribovis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_ulceribovis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121370"]),
        None,
        Some("."),
        Some("AQUY0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gryllotalpicola ginsengisoli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121372.AULK01000001_gene1814";
/// let this_library_node_name2 = "1121372.AULK01000023_gene1799";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gryllotalpicola_ginsengisoli_node_name(this_library_node_name1));
/// assert!(is_valid_string_gryllotalpicola_ginsengisoli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gryllotalpicola_ginsengisoli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gryllotalpicola_ginsengisoli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121372"]),
        None,
        Some("."),
        Some("AULK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cytophaga aurantiaca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121373.KB903620_gene1965";
/// let this_library_node_name2 = "1121373.KB903666_gene1391";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cytophaga_aurantiaca_node_name(this_library_node_name1));
/// assert!(is_valid_string_cytophaga_aurantiaca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cytophaga_aurantiaca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cytophaga_aurantiaca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121373"]),
        None,
        Some("."),
        Some("KB9036"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dasania marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121374.KB891575_gene1000";
/// let this_library_node_name2 = "1121374.KB891592_gene2970";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dasania_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_dasania_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dasania_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dasania_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121374"]),
        None,
        Some("."),
        Some("KB8915"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus apachensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121377.KB906398_gene1941";
/// let this_library_node_name2 = "1121377.KB906447_gene4037";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_apachensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_apachensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_apachensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_apachensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121377"]),
        None,
        Some("."),
        Some("KB906"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus aquatilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121378.KB899695_gene2971";
/// let this_library_node_name2 = "1121378.KB899807_gene3572";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_aquatilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_aquatilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_aquatilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_aquatilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121378"]),
        None,
        Some("."),
        Some("KB899"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus frigens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121380.JNIW01000001_gene2749";
/// let this_library_node_name2 = "1121380.JNIW01000150_gene3413";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_frigens_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_frigens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_frigens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_frigens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121380"]),
        None,
        Some("."),
        Some("JNIW01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus marmoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121381.JNIV01000001_gene2795";
/// let this_library_node_name2 = "1121381.JNIV01000252_gene355";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_marmoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_marmoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_marmoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_marmoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121381"]),
        None,
        Some("."),
        Some("JNIV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus misasensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121382.JQKG01000001_gene2220";
/// let this_library_node_name2 = "1121382.JQKG01000104_gene2571";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_misasensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_misasensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_misasensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_misasensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121382"]),
        None,
        Some("."),
        Some("JQKG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Demetria terragena nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121385.AQXW01000001_gene628";
/// let this_library_node_name2 = "1121385.AQXW01000004_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_demetria_terragena_node_name(this_library_node_name1));
/// assert!(is_valid_string_demetria_terragena_node_name(this_library_node_name2));
/// assert!(!is_valid_string_demetria_terragena_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_demetria_terragena_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121385"]),
        None,
        Some("."),
        Some("AQXW0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfobacter curvatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121396.KB892900_gene2027";
/// let this_library_node_name2 = "1121396.KB893133_gene663";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfobacter_curvatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfobacter_curvatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfobacter_curvatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfobacter_curvatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121396"]),
        None,
        Some("."),
        Some("KB89"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfobulbus japonicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121403.AUCV01000001_gene1000";
/// let this_library_node_name2 = "1121403.AUCV01000135_gene3353";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfobulbus_japonicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfobulbus_japonicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfobulbus_japonicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfobulbus_japonicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121403"]),
        None,
        Some("."),
        Some("AUCV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfococcus multivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121405.dsmv_0001";
/// let this_library_node_name2 = "1121405.dsmv_3853";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfococcus_multivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfococcus_multivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfococcus_multivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfococcus_multivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121405"]),
        None,
        Some("."),
        Some("dsmv_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfocurvus vexinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121406.JAEX01000001_gene1";
/// let this_library_node_name2 = "1121406.JAEX01000060_gene2580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfocurvus_vexinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfocurvus_vexinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfocurvus_vexinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfocurvus_vexinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121406"]),
        None,
        Some("."),
        Some("JAEX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfonatronovibrio hydrogenovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121413.JMKT01000001_gene1679";
/// let this_library_node_name2 = "1121413.JMKT01000017_gene476";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfonatronovibrio_hydrogenovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfonatronovibrio_hydrogenovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfonatronovibrio_hydrogenovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfonatronovibrio_hydrogenovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121413"]),
        None,
        Some("."),
        Some("JMKT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum alcoholivorax nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121422.AUMW01000001_gene2308";
/// let this_library_node_name2 = "1121422.AUMW01000065_gene1311";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_alcoholivorax_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_alcoholivorax_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_alcoholivorax_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_alcoholivorax_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121422"]),
        None,
        Some("."),
        Some("AUMW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum alkaliphilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121423.JONT01000001_gene1833";
/// let this_library_node_name2 = "1121423.JONT01000067_gene26";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_alkaliphilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_alkaliphilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_alkaliphilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_alkaliphilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121423"]),
        None,
        Some("."),
        Some("JONT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum hydrothermale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121428.DESHY_100001___1";
/// let this_library_node_name2 = "1121428.DESHY_90016___1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_hydrothermale_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_hydrothermale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_hydrothermale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_hydrothermale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121428"]),
        None,
        Some("."),
        Some("DESHY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum thermocisternum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121430.JMLG01000001_gene2040";
/// let this_library_node_name2 = "1121430.JMLG01000048_gene1454";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_thermocisternum_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_thermocisternum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_thermocisternum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_thermocisternum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121430"]),
        None,
        Some("."),
        Some("JMLG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio acrylicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121434.AULY01000001_gene2665";
/// let this_library_node_name2 = "1121434.AULY01000015_gene2687";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_acrylicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_acrylicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_acrylicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_acrylicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121434"]),
        None,
        Some("."),
        Some("AULY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio alcoholivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121438.JNJA01000001_gene2047";
/// let this_library_node_name2 = "1121438.JNJA01000061_gene3336";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_alcoholivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_alcoholivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_alcoholivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_alcoholivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121438"]),
        None,
        Some("."),
        Some("JNJA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio alkalitolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121439.dsat_0001";
/// let this_library_node_name2 = "1121439.dsat_2924";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_alkalitolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_alkalitolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_alkalitolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_alkalitolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121439"]),
        None,
        Some("."),
        Some("dsat_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio aminophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121440.AUMA01000001_gene1";
/// let this_library_node_name2 = "1121440.AUMA01000029_gene3160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_aminophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_aminophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_aminophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_aminophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121440"]),
        None,
        Some("."),
        Some("AUMA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio bastinii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121441.AUCX01000001_gene2604";
/// let this_library_node_name2 = "1121441.AUCX01000042_gene1585";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_bastinii_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_bastinii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_bastinii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_bastinii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121441"]),
        None,
        Some("."),
        Some("AUCX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio desulfuricans DSM642 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121445.ATUZ01000001_gene112";
/// let this_library_node_name2 = "1121445.ATUZ01000020_gene2192";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_desulfuricans_dsm642_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_desulfuricans_dsm642_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_desulfuricans_dsm642_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_desulfuricans_dsm642_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121445"]),
        None,
        Some("."),
        Some("ATUZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio frigidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121447.JONL01000001_gene1000";
/// let this_library_node_name2 = "1121447.JONL01000024_gene2501";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_frigidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_frigidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_frigidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_frigidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121447"]),
        None,
        Some("."),
        Some("JONL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio gigas nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121448.DGI_0001";
/// let this_library_node_name2 = "1121448.DGI_4074";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_gigas_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_gigas_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_gigas_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_gigas_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121448"]),
        None,
        Some("."),
        Some("DGI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio hydrothermalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121451.DESAM_10001";
/// let this_library_node_name2 = "1121451.DESAM_p0005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_hydrothermalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_hydrothermalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_hydrothermalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_hydrothermalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121451"]),
        None,
        Some("."),
        Some("DESAM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio longus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121456.ATVA01000001_gene3057";
/// let this_library_node_name2 = "1121456.ATVA01000019_gene1340";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_longus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_longus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_longus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_longus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121456"]),
        None,
        Some("."),
        Some("ATVA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio oxyclinae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121459.AQXE01000001_gene2487";
/// let this_library_node_name2 = "1121459.AQXE01000031_gene2360";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_oxyclinae_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_oxyclinae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_oxyclinae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_oxyclinae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121459"]),
        None,
        Some("."),
        Some("AQXE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovirgula thermocuniculi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121468.AUBR01000001_gene400";
/// let this_library_node_name2 = "1121468.AUBR01000137_gene1144";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovirgula_thermocuniculi_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovirgula_thermocuniculi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovirgula_thermocuniculi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovirgula_thermocuniculi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121468"]),
        None,
        Some("."),
        Some("AUBR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfurispora thermophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121472.AQWN01000001_gene1";
/// let this_library_node_name2 = "1121472.AQWN01000018_gene1849";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfurispora_thermophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfurispora_thermophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfurispora_thermophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfurispora_thermophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121472"]),
        None,
        Some("."),
        Some("AQWN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Donghicola xiamenensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121479.AUBS01000001_gene3020";
/// let this_library_node_name2 = "1121479.AUBS01000090_gene683";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_donghicola_xiamenensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_donghicola_xiamenensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_donghicola_xiamenensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_donghicola_xiamenensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121479"]),
        None,
        Some("."),
        Some("AUBS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dyadobacter alkalitolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121481.AUAS01000001_gene4318";
/// let this_library_node_name2 = "1121481.AUAS01000051_gene2873";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dyadobacter_alkalitolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_dyadobacter_alkalitolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dyadobacter_alkalitolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dyadobacter_alkalitolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121481"]),
        None,
        Some("."),
        Some("AUAS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Echinicola pacifica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121859.KB890738_gene2868";
/// let this_library_node_name2 = "1121859.KB890760_gene2100";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_echinicola_pacifica_node_name(this_library_node_name1));
/// assert!(is_valid_string_echinicola_pacifica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_echinicola_pacifica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_echinicola_pacifica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121859"]),
        None,
        Some("."),
        Some("KB8907"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Elioraea tepidiphila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121861.KB899910_gene622";
/// let this_library_node_name2 = "1121861.KB899964_gene3198";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_elioraea_tepidiphila_node_name(this_library_node_name1));
/// assert!(is_valid_string_elioraea_tepidiphila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_elioraea_tepidiphila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_elioraea_tepidiphila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121861"]),
        None,
        Some("."),
        Some("KB8999"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus cecorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121864.OMO_00004";
/// let this_library_node_name2 = "1121864.OMO_02470";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_cecorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_cecorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_cecorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_cecorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121864"]),
        None,
        Some("."),
        Some("OMO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus columbae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121865.OMW_00004";
/// let this_library_node_name2 = "1121865.OMW_02417";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_columbae_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_columbae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_columbae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_columbae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121865"]),
        None,
        Some("."),
        Some("OMW_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterorhabdus mucosicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121866.AUGK01000001_gene753";
/// let this_library_node_name2 = "1121866.AUGK01000028_gene1447";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterorhabdus_mucosicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterorhabdus_mucosicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterorhabdus_mucosicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterorhabdus_mucosicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121866"]),
        None,
        Some("."),
        Some("AUGK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Epilithonimonas tenax nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121870.AUAA01000001_gene2607";
/// let this_library_node_name2 = "1121870.AUAA01000109_gene2845";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_epilithonimonas_tenax_node_name(this_library_node_name1));
/// assert!(is_valid_string_epilithonimonas_tenax_node_name(this_library_node_name2));
/// assert!(!is_valid_string_epilithonimonas_tenax_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_epilithonimonas_tenax_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121870"]),
        None,
        Some("."),
        Some("AUAA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eremococcus coleocola DSM15696 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121871.AUAT01000001_gene716";
/// let this_library_node_name2 = "1121871.AUAT01000051_gene908";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eremococcus_coleocola_dsm15696_node_name(this_library_node_name1));
/// assert!(is_valid_string_eremococcus_coleocola_dsm15696_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eremococcus_coleocola_dsm15696_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eremococcus_coleocola_dsm15696_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121871"]),
        None,
        Some("."),
        Some("AUAT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Erysipelothrix tonsillarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121874.KB892377_gene1000";
/// let this_library_node_name2 = "1121874.KB892380_gene1787";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_erysipelothrix_tonsillarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_erysipelothrix_tonsillarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_erysipelothrix_tonsillarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_erysipelothrix_tonsillarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121874"]),
        None,
        Some("."),
        Some("KB8923"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eudoraea adriatica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121875.KB907546_gene2172";
/// let this_library_node_name2 = "1121875.KB907564_gene342";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eudoraea_adriatica_node_name(this_library_node_name1));
/// assert!(is_valid_string_eudoraea_adriatica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eudoraea_adriatica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eudoraea_adriatica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121875"]),
        None,
        Some("."),
        Some("KB9075"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ferrimicrobium acidiphilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121877.JQKF01000001_gene1267";
/// let this_library_node_name2 = "1121877.JQKF01000112_gene1255";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ferrimicrobium_acidiphilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_ferrimicrobium_acidiphilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ferrimicrobium_acidiphilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ferrimicrobium_acidiphilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121877"]),
        None,
        Some("."),
        Some("JQKF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ferrimonas futtsuensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121878.AUGL01000001_gene112";
/// let this_library_node_name2 = "1121878.AUGL01000040_gene2102";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ferrimonas_futtsuensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_ferrimonas_futtsuensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ferrimonas_futtsuensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ferrimonas_futtsuensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121878"]),
        None,
        Some("."),
        Some("AUGL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium daejeonense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121887.AUDK01000001_gene455";
/// let this_library_node_name2 = "1121887.AUDK01000052_gene103";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_daejeonense_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_daejeonense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_daejeonense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_daejeonense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121887"]),
        None,
        Some("."),
        Some("AUDK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium filum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121889.AUDM01000001_gene117";
/// let this_library_node_name2 = "1121889.AUDM01000052_gene492";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_filum_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_filum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_filum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_filum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121889"]),
        None,
        Some("."),
        Some("AUDM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium frigidarium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121890.AUDO01000001_gene1000";
/// let this_library_node_name2 = "1121890.AUDO01000039_gene3130";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_frigidarium_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_frigidarium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_frigidarium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_frigidarium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121890"]),
        None,
        Some("."),
        Some("AUDO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium rivuli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121895.Q765_00005";
/// let this_library_node_name2 = "1121895.Q765_20890";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_rivuli_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_rivuli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_rivuli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_rivuli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121895"]),
        None,
        Some("."),
        Some("Q765_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium sasangense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121896.JMLU01000001_gene1000";
/// let this_library_node_name2 = "1121896.JMLU01000073_gene2561";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_sasangense_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_sasangense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_sasangense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_sasangense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121896"]),
        None,
        Some("."),
        Some("JMLU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium soli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121897.AUGO01000001_gene1121";
/// let this_library_node_name2 = "1121897.AUGO01000024_gene2512";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_soli_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_soli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_soli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_soli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121897"]),
        None,
        Some("."),
        Some("AUGO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium subsaxonicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121898.Q766_00005";
/// let this_library_node_name2 = "1121898.Q766_21285";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_subsaxonicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_subsaxonicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_subsaxonicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_subsaxonicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121898"]),
        None,
        Some("."),
        Some("Q766_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium suncheonense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121899.Q764_00005";
/// let this_library_node_name2 = "1121899.Q764_14560";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_suncheonense_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_suncheonense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_suncheonense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_suncheonense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121899"]),
        None,
        Some("."),
        Some("Q764_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flexithrix dorotheae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121904.ARBP01000001_gene5321";
/// let this_library_node_name2 = "1121904.ARBP01000105_gene2543";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flexithrix_dorotheae_node_name(this_library_node_name1));
/// assert!(is_valid_string_flexithrix_dorotheae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flexithrix_dorotheae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flexithrix_dorotheae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121904"]),
        None,
        Some("."),
        Some("ARBP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gelidibacter mesophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121912.AUHD01000001_gene2237";
/// let this_library_node_name2 = "1121912.AUHD01000056_gene1496";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gelidibacter_mesophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_gelidibacter_mesophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gelidibacter_mesophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gelidibacter_mesophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121912"]),
        None,
        Some("."),
        Some("AUHD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemella cuniculi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121914.AUDW01000001_gene491";
/// let this_library_node_name2 = "1121914.AUDW01000039_gene1725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemella_cuniculi_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemella_cuniculi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemella_cuniculi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemella_cuniculi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121914"]),
        None,
        Some("."),
        Some("AUDW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geopsychrobacter electrodiphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121918.ARWE01000001_gene1";
/// let this_library_node_name2 = "1121918.ARWE01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geopsychrobacter_electrodiphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_geopsychrobacter_electrodiphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geopsychrobacter_electrodiphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geopsychrobacter_electrodiphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121918"]),
        None,
        Some("."),
        Some("ARWE01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geothrix fermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121920.AUAU01000001_gene2168";
/// let this_library_node_name2 = "1121920.AUAU01000042_gene1405";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geothrix_fermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_geothrix_fermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geothrix_fermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geothrix_fermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121920"]),
        None,
        Some("."),
        Some("AUAU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gilvimarinus chinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121921.KB898706_gene2286";
/// let this_library_node_name2 = "1121921.KB898722_gene2260";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gilvimarinus_chinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gilvimarinus_chinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gilvimarinus_chinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gilvimarinus_chinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121921"]),
        None,
        Some("."),
        Some("KB8987"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glaciecola punicea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121923.GPUN_0001";
/// let this_library_node_name2 = "1121923.GPUN_2924";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glaciecola_punicea_node_name(this_library_node_name1));
/// assert!(is_valid_string_glaciecola_punicea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glaciecola_punicea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glaciecola_punicea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121923"]),
        None,
        Some("."),
        Some("GPUN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glaciibacter superstes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121924.ATWH01000001_gene4098";
/// let this_library_node_name2 = "1121924.ATWH01000037_gene199";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glaciibacter_superstes_node_name(this_library_node_name1));
/// assert!(is_valid_string_glaciibacter_superstes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glaciibacter_superstes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glaciibacter_superstes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121924"]),
        None,
        Some("."),
        Some("ATWH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glycomyces arizonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121926.AXWO01000001_gene3282";
/// let this_library_node_name2 = "1121926.AXWO01000054_gene930";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glycomyces_arizonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_glycomyces_arizonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glycomyces_arizonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glycomyces_arizonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121926"]),
        None,
        Some("."),
        Some("AXWO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia hirsuta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121927.GOHSU_01_00010";
/// let this_library_node_name2 = "1121927.GOHSU_77_00020";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_hirsuta_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_hirsuta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_hirsuta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_hirsuta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121927"]),
        None,
        Some("."),
        Some("GOHSU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia shandongensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121928.AUHE01000001_gene1481";
/// let this_library_node_name2 = "1121928.AUHE01000034_gene431";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_shandongensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_shandongensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_shandongensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_shandongensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121928"]),
        None,
        Some("."),
        Some("AUHE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gracilibacillus lacisalsi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121929.KB898662_gene278";
/// let this_library_node_name2 = "1121929.KB898705_gene2336";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gracilibacillus_lacisalsi_node_name(this_library_node_name1));
/// assert!(is_valid_string_gracilibacillus_lacisalsi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gracilibacillus_lacisalsi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gracilibacillus_lacisalsi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121929"]),
        None,
        Some("."),
        Some("KB898"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gracilimonas tropica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121930.AQXG01000001_gene1000";
/// let this_library_node_name2 = "1121930.AQXG01000048_gene26";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gracilimonas_tropica_node_name(this_library_node_name1));
/// assert!(is_valid_string_gracilimonas_tropica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gracilimonas_tropica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gracilimonas_tropica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121930"]),
        None,
        Some("."),
        Some("AQXG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gramella echinicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121931.AUHG01000001_gene3080";
/// let this_library_node_name2 = "1121931.AUHG01000020_gene3176";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gramella_echinicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_gramella_echinicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gramella_echinicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gramella_echinicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121931"]),
        None,
        Some("."),
        Some("AUHG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Granulicoccus phenolivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121933.AUHH01000001_gene2074";
/// let this_library_node_name2 = "1121933.AUHH01000080_gene1930";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_granulicoccus_phenolivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_granulicoccus_phenolivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_granulicoccus_phenolivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_granulicoccus_phenolivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121933"]),
        None,
        Some("."),
        Some("AUHH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gulosibacter molinativorax nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121934.AUDX01000001_gene2211";
/// let this_library_node_name2 = "1121934.AUDX01000081_gene2765";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gulosibacter_molinativorax_node_name(this_library_node_name1));
/// assert!(is_valid_string_gulosibacter_molinativorax_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gulosibacter_molinativorax_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gulosibacter_molinativorax_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121934"]),
        None,
        Some("."),
        Some("AUDX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hahella ganghwensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121935.AQXX01000001_gene5836";
/// let this_library_node_name2 = "1121935.AQXX01000144_gene4573";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hahella_ganghwensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_hahella_ganghwensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hahella_ganghwensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hahella_ganghwensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121935"]),
        None,
        Some("."),
        Some("AQXX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halalkalibacillus halophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121936.AUHI01000001_gene1000";
/// let this_library_node_name2 = "1121936.AUHI01000027_gene728";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halalkalibacillus_halophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_halalkalibacillus_halophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halalkalibacillus_halophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halalkalibacillus_halophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121936"]),
        None,
        Some("."),
        Some("AUHI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haliea salexigens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121937.AUHJ01000001_gene293";
/// let this_library_node_name2 = "1121937.AUHJ01000078_gene275";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haliea_salexigens_node_name(this_library_node_name1));
/// assert!(is_valid_string_haliea_salexigens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haliea_salexigens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haliea_salexigens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121937"]),
        None,
        Some("."),
        Some("AUHJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halobacillus kuroshimensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121938.AUDY01000002_gene399";
/// let this_library_node_name2 = "1121938.AUDY01000016_gene3075";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halobacillus_kuroshimensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_halobacillus_kuroshimensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halobacillus_kuroshimensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halobacillus_kuroshimensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121938"]),
        None,
        Some("."),
        Some("AUDY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas anticariensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121939.L861_00005";
/// let this_library_node_name2 = "1121939.L861_24240";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_anticariensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_anticariensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_anticariensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_anticariensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121939"]),
        None,
        Some("."),
        Some("L861_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas halocynthiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121940.AUDZ01000003_gene2426";
/// let this_library_node_name2 = "1121940.AUDZ01000018_gene456";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_halocynthiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_halocynthiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_halocynthiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_halocynthiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121940"]),
        None,
        Some("."),
        Some("AUDZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas lutea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121943.KB899989_gene3107";
/// let this_library_node_name2 = "1121943.KB900026_gene2753";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_lutea_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_lutea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_lutea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_lutea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121943"]),
        None,
        Some("."),
        Some("KB"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halorubrum ezzemoulense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121945.ATXS01000001_gene1951";
/// let this_library_node_name2 = "1121945.ATXS01000087_gene256";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halorubrum_ezzemoulense_node_name(this_library_node_name1));
/// assert!(is_valid_string_halorubrum_ezzemoulense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halorubrum_ezzemoulense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halorubrum_ezzemoulense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121945"]),
        None,
        Some("."),
        Some("ATXS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hamadaea tsunoensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121946.AUAX01000001_gene2079";
/// let this_library_node_name2 = "1121946.AUAX01000072_gene4143";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hamadaea_tsunoensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_hamadaea_tsunoensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hamadaea_tsunoensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hamadaea_tsunoensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121946"]),
        None,
        Some("."),
        Some("AUAX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helcococcus sueciensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121947.AUHK01000001_gene719";
/// let this_library_node_name2 = "1121947.AUHK01000045_gene353";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helcococcus_sueciensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_helcococcus_sueciensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helcococcus_sueciensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helcococcus_sueciensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121947"]),
        None,
        Some("."),
        Some("AUHK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hellea balneolensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121948.AUAC01000001_gene2937";
/// let this_library_node_name2 = "1121948.AUAC01000011_gene712";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hellea_balneolensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_hellea_balneolensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hellea_balneolensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hellea_balneolensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121948"]),
        None,
        Some("."),
        Some("AUAC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Henriciella marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121949.AQXT01000002_gene1";
/// let this_library_node_name2 = "1121949.AQXT01000002_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_henriciella_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_henriciella_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_henriciella_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_henriciella_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121949"]),
        None,
        Some("."),
        Some("AQXT01000002_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Humibacter albus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121952.ATXT01000001_gene1143";
/// let this_library_node_name2 = "1121952.ATXT01000020_gene1765";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_humibacter_albus_node_name(this_library_node_name1));
/// assert!(is_valid_string_humibacter_albus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_humibacter_albus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_humibacter_albus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121952"]),
        None,
        Some("."),
        Some("ATXT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hymenobacter norwichensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1121957.ATVL01000001_gene3467";
/// let this_library_node_name2 = "1121957.ATVL01000014_gene1525";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hymenobacter_norwichensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_hymenobacter_norwichensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hymenobacter_norwichensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hymenobacter_norwichensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1121957"]),
        None,
        Some("."),
        Some("ATVL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Jeotgalicoccus marinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122128.AUEE01000001_gene2099";
/// let this_library_node_name2 = "1122128.AUEE01000029_gene265";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_jeotgalicoccus_marinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_jeotgalicoccus_marinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_jeotgalicoccus_marinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_jeotgalicoccus_marinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122128"]),
        None,
        Some("."),
        Some("AUEE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Jeotgalicoccus psychrophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122129.AUEF01000001_gene1000";
/// let this_library_node_name2 = "1122129.AUEF01000032_gene2352";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_jeotgalicoccus_psychrophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_jeotgalicoccus_psychrophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_jeotgalicoccus_psychrophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_jeotgalicoccus_psychrophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122129"]),
        None,
        Some("."),
        Some("AUEF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Jonesia quinghaiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122130.AUHN01000002_gene2575";
/// let this_library_node_name2 = "1122130.AUHN01000013_gene2608";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_jonesia_quinghaiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_jonesia_quinghaiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_jonesia_quinghaiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_jonesia_quinghaiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122130"]),
        None,
        Some("."),
        Some("AUHN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kaistia granuli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122132.AQYH01000001_gene779";
/// let this_library_node_name2 = "1122132.AQYH01000020_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kaistia_granuli_node_name(this_library_node_name1));
/// assert!(is_valid_string_kaistia_granuli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kaistia_granuli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kaistia_granuli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122132"]),
        None,
        Some("."),
        Some("AQYH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kangiella aquimarina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122134.KB893650_gene1";
/// let this_library_node_name2 = "1122134.KB893652_gene2431";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kangiella_aquimarina_node_name(this_library_node_name1));
/// assert!(is_valid_string_kangiella_aquimarina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kangiella_aquimarina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kangiella_aquimarina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122134"]),
        None,
        Some("."),
        Some("KB89365"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kiloniella laminariae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122135.KB893134_gene3123";
/// let this_library_node_name2 = "1122135.KB893171_gene2153";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kiloniella_laminariae_node_name(this_library_node_name1));
/// assert!(is_valid_string_kiloniella_laminariae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kiloniella_laminariae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kiloniella_laminariae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122135"]),
        None,
        Some("."),
        Some("KB8931"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kordiimonas gwangyangensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122137.AQXF01000001_gene2492";
/// let this_library_node_name2 = "1122137.AQXF01000013_gene3";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kordiimonas_gwangyangensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_kordiimonas_gwangyangensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kordiimonas_gwangyangensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kordiimonas_gwangyangensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122137"]),
        None,
        Some("."),
        Some("AQXF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kribbella catacumbae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122138.AQUZ01000001_gene1468";
/// let this_library_node_name2 = "1122138.AQUZ01000152_gene5379";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kribbella_catacumbae_node_name(this_library_node_name1));
/// assert!(is_valid_string_kribbella_catacumbae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kribbella_catacumbae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kribbella_catacumbae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122138"]),
        None,
        Some("."),
        Some("AQUZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kushneria aurantia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122139.KB907862_gene525";
/// let this_library_node_name2 = "1122139.KB907923_gene16";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kushneria_aurantia_node_name(this_library_node_name1));
/// assert!(is_valid_string_kushneria_aurantia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kushneria_aurantia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kushneria_aurantia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122139"]),
        None,
        Some("."),
        Some("KB907"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lacticigenium naphtae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122143.AUEG01000001_gene107";
/// let this_library_node_name2 = "1122143.AUEG01000036_gene1969";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lacticigenium_naphtae_node_name(this_library_node_name1));
/// assert!(is_valid_string_lacticigenium_naphtae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lacticigenium_naphtae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lacticigenium_naphtae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122143"]),
        None,
        Some("."),
        Some("AUEG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus ceti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122146.AUHP01000001_gene674";
/// let this_library_node_name2 = "1122146.AUHP01000019_gene1244";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_ceti_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_ceti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_ceti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_ceti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122146"]),
        None,
        Some("."),
        Some("AUHP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus harbinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122147.AUEH01000001_gene305";
/// let this_library_node_name2 = "1122147.AUEH01000102_gene644";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_harbinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_harbinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_harbinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_harbinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122147"]),
        None,
        Some("."),
        Some("AUEH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus malefermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122149.BACN01000001_gene282";
/// let this_library_node_name2 = "1122149.BACN01000171_gene2003";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_malefermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_malefermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_malefermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_malefermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122149"]),
        None,
        Some("."),
        Some("BACN01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus psittaci nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122152.AUEI01000001_gene582";
/// let this_library_node_name2 = "1122152.AUEI01000026_gene1347";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_psittaci_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_psittaci_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_psittaci_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_psittaci_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122152"]),
        None,
        Some("."),
        Some("AUEI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella lansingensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122164.JHWF01000001_gene1854";
/// let this_library_node_name2 = "1122164.JHWF01000061_gene1220";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_lansingensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_lansingensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_lansingensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_lansingensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122164"]),
        None,
        Some("."),
        Some("JHWF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella moravica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122165.AUHS01000001_gene1221";
/// let this_library_node_name2 = "1122165.AUHS01000060_gene3086";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_moravica_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_moravica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_moravica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_moravica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122165"]),
        None,
        Some("."),
        Some("AUHS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella shakespearei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122169.AREN01000001_gene929";
/// let this_library_node_name2 = "1122169.AREN01000070_gene2759";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_shakespearei_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_shakespearei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_shakespearei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_shakespearei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122169"]),
        None,
        Some("."),
        Some("AREN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptotrichia shahii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122172.KB890259_gene1000";
/// let this_library_node_name2 = "1122172.KB890278_gene1579";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptotrichia_shahii_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptotrichia_shahii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptotrichia_shahii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptotrichia_shahii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122172"]),
        None,
        Some("."),
        Some("KB8902"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptotrichia trevisanii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122173.AXVL01000001_gene1646";
/// let this_library_node_name2 = "1122173.AXVL01000091_gene602";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptotrichia_trevisanii_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptotrichia_trevisanii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptotrichia_trevisanii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptotrichia_trevisanii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122173"]),
        None,
        Some("."),
        Some("AXVL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leucobacter chironomi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122175.ATXU01000001_gene1000";
/// let this_library_node_name2 = "1122175.ATXU01000027_gene1755";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leucobacter_chironomi_node_name(this_library_node_name1));
/// assert!(is_valid_string_leucobacter_chironomi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leucobacter_chironomi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leucobacter_chironomi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122175"]),
        None,
        Some("."),
        Some("ATXU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lewinella cohaerens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122176.KB903531_gene2760";
/// let this_library_node_name2 = "1122176.KB903619_gene5467";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lewinella_cohaerens_node_name(this_library_node_name1));
/// assert!(is_valid_string_lewinella_cohaerens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lewinella_cohaerens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lewinella_cohaerens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122176"]),
        None,
        Some("."),
        Some("KB903"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lewinella persica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122179.KB890413_gene4660";
/// let this_library_node_name2 = "1122179.KB890497_gene2892";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lewinella_persica_node_name(this_library_node_name1));
/// assert!(is_valid_string_lewinella_persica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lewinella_persica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lewinella_persica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122179"]),
        None,
        Some("."),
        Some("KB8904"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Loktanella hongkongensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122180.Lokhon_00086";
/// let this_library_node_name2 = "1122180.Lokhon_03157";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_loktanella_hongkongensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_loktanella_hongkongensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_loktanella_hongkongensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_loktanella_hongkongensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122180"]),
        None,
        Some("."),
        Some("Lokhon_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Longispora albida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122182.KB903813_gene2045";
/// let this_library_node_name2 = "1122182.KB903839_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_longispora_albida_node_name(this_library_node_name1));
/// assert!(is_valid_string_longispora_albida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_longispora_albida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_longispora_albida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122182"]),
        None,
        Some("."),
        Some("KB9038"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysobacter concretionis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122185.N792_00005";
/// let this_library_node_name2 = "1122185.N792_13500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysobacter_concretionis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysobacter_concretionis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysobacter_concretionis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysobacter_concretionis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122185"]),
        None,
        Some("."),
        Some("N792_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinimicrobium agarilyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122194.AUHU01000001_gene1";
/// let this_library_node_name2 = "1122194.AUHU01000030_gene2430";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinimicrobium_agarilyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinimicrobium_agarilyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinimicrobium_agarilyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinimicrobium_agarilyticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122194"]),
        None,
        Some("."),
        Some("AUHU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter daepoensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122197.ATWI01000001_gene1276";
/// let this_library_node_name2 = "1122197.ATWI01000016_gene2229";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_daepoensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_daepoensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_daepoensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_daepoensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122197"]),
        None,
        Some("."),
        Some("ATWI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacterium litorale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122201.AUAZ01000001_gene2210";
/// let this_library_node_name2 = "1122201.AUAZ01000067_gene1623";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacterium_litorale_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacterium_litorale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacterium_litorale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacterium_litorale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122201"]),
        None,
        Some("."),
        Some("AUAZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinomonas ushuaiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122207.MUS1_00005";
/// let this_library_node_name2 = "1122207.MUS1_15885";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinomonas_ushuaiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinomonas_ushuaiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinomonas_ushuaiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinomonas_ushuaiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122207"]),
        None,
        Some("."),
        Some("MUS1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinospirillum insulare nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122211.JMLW01000001_gene2088";
/// let this_library_node_name2 = "1122211.JMLW01000072_gene2448";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinospirillum_insulare_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinospirillum_insulare_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinospirillum_insulare_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinospirillum_insulare_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122211"]),
        None,
        Some("."),
        Some("JMLW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinospirillum minutulum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122212.AULO01000001_gene2122";
/// let this_library_node_name2 = "1122212.AULO01000015_gene2121";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinospirillum_minutulum_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinospirillum_minutulum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinospirillum_minutulum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinospirillum_minutulum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122212"]),
        None,
        Some("."),
        Some("AULO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Martelella mediterranea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122214.AQWH01000001_gene515";
/// let this_library_node_name2 = "1122214.AQWH01000075_gene3098";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_martelella_mediterranea_node_name(this_library_node_name1));
/// assert!(is_valid_string_martelella_mediterranea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_martelella_mediterranea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_martelella_mediterranea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122214"]),
        None,
        Some("."),
        Some("AQWH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Megamonas hypermegale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122216.AUHW01000001_gene643";
/// let this_library_node_name2 = "1122216.AUHW01000059_gene2040";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_megamonas_hypermegale_node_name(this_library_node_name1));
/// assert!(is_valid_string_megamonas_hypermegale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_megamonas_hypermegale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_megamonas_hypermegale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122216"]),
        None,
        Some("."),
        Some("AUHW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Megamonas rupellensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122217.KB899566_gene412";
/// let this_library_node_name2 = "1122217.KB899635_gene2217";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_megamonas_rupellensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_megamonas_rupellensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_megamonas_rupellensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_megamonas_rupellensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122217"]),
        None,
        Some("."),
        Some("KB899"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Meganema perideroedes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122218.KB893653_gene1000";
/// let this_library_node_name2 = "1122218.KB893669_gene1586";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_meganema_perideroedes_node_name(this_library_node_name1));
/// assert!(is_valid_string_meganema_perideroedes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_meganema_perideroedes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_meganema_perideroedes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122218"]),
        None,
        Some("."),
        Some("KB8936"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Meiothermus cerbereus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122221.JHVI01000001_gene1760";
/// let this_library_node_name2 = "1122221.JHVI01000057_gene2856";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_meiothermus_cerbereus_node_name(this_library_node_name1));
/// assert!(is_valid_string_meiothermus_cerbereus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_meiothermus_cerbereus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_meiothermus_cerbereus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122221"]),
        None,
        Some("."),
        Some("JHVI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Meiothermus taiwanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122222.AXWR01000001_gene1807";
/// let this_library_node_name2 = "1122222.AXWR01000076_gene59";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_meiothermus_taiwanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_meiothermus_taiwanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_meiothermus_taiwanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_meiothermus_taiwanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122222"]),
        None,
        Some("."),
        Some("AXWR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Meiothermus timidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122223.KB890687_gene2368";
/// let this_library_node_name2 = "1122223.KB890703_gene1322";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_meiothermus_timidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_meiothermus_timidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_meiothermus_timidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_meiothermus_timidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122223"]),
        None,
        Some("."),
        Some("KB890"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesoflavibacter zeaxanth. DSM18436 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122225.AULQ01000001_gene1389";
/// let this_library_node_name2 = "1122225.AULQ01000022_gene405";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesoflavibacter_zeaxanth_dsm18436_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesoflavibacter_zeaxanth_dsm18436_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesoflavibacter_zeaxanth_dsm18436_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesoflavibacter_zeaxanth_dsm18436_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122225"]),
        None,
        Some("."),
        Some("AULQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesonia mobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122226.AUHX01000001_gene1000";
/// let this_library_node_name2 = "1122226.AUHX01000062_gene352";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesonia_mobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesonia_mobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesonia_mobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesonia_mobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122226"]),
        None,
        Some("."),
        Some("AUHX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Metascardovia criceti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122228.AQXR01000001_gene2";
/// let this_library_node_name2 = "1122228.AQXR01000011_gene636";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_metascardovia_criceti_node_name(this_library_node_name1));
/// assert!(is_valid_string_metascardovia_criceti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_metascardovia_criceti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_metascardovia_criceti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122228"]),
        None,
        Some("."),
        Some("AQXR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylophilus methylotrophus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122236.KB905141_gene1000";
/// let this_library_node_name2 = "1122236.KB905154_gene2253";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylophilus_methylotrophus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylophilus_methylotrophus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylophilus_methylotrophus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylophilus_methylotrophus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122236"]),
        None,
        Some("."),
        Some("KB9051"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium gubbeenense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122237.AUGQ01000001_gene1000";
/// let this_library_node_name2 = "1122237.AUGQ01000075_gene2651";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_gubbeenense_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_gubbeenense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_gubbeenense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_gubbeenense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122237"]),
        None,
        Some("."),
        Some("AUGQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium indicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122238.AULR01000001_gene1592";
/// let this_library_node_name2 = "1122238.AULR01000028_gene1040";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_indicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_indicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_indicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_indicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122238"]),
        None,
        Some("."),
        Some("AULR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium luticocti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122239.AULS01000001_gene1624";
/// let this_library_node_name2 = "1122239.AULS01000030_gene2507";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_luticocti_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_luticocti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_luticocti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_luticocti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122239"]),
        None,
        Some("."),
        Some("AULS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moraxella boevrei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122243.KB903770_gene505";
/// let this_library_node_name2 = "1122243.KB903812_gene905";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moraxella_boevrei_node_name(this_library_node_name1));
/// assert!(is_valid_string_moraxella_boevrei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moraxella_boevrei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moraxella_boevrei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122243"]),
        None,
        Some("."),
        Some("KB903"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moraxella caprae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122244.AUGF01000001_gene1704";
/// let this_library_node_name2 = "1122244.AUGF01000108_gene590";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moraxella_caprae_node_name(this_library_node_name1));
/// assert!(is_valid_string_moraxella_caprae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moraxella_caprae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moraxella_caprae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122244"]),
        None,
        Some("."),
        Some("AUGF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium hassiacum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122247.C731_0001";
/// let this_library_node_name2 = "1122247.C731_5011";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_hassiacum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_hassiacum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_hassiacum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_hassiacum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122247"]),
        None,
        Some("."),
        Some("C731_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Neptunomonas japonica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122599.AUGR01000001_gene100";
/// let this_library_node_name2 = "1122599.AUGR01000042_gene3669";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_neptunomonas_japonica_node_name(this_library_node_name1));
/// assert!(is_valid_string_neptunomonas_japonica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_neptunomonas_japonica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_neptunomonas_japonica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122599"]),
        None,
        Some("."),
        Some("AUGR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nesterenkonia alba nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122602.ATXP01000001_gene1000";
/// let this_library_node_name2 = "1122602.ATXP01000036_gene2160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nesterenkonia_alba_node_name(this_library_node_name1));
/// assert!(is_valid_string_nesterenkonia_alba_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nesterenkonia_alba_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nesterenkonia_alba_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122602"]),
        None,
        Some("."),
        Some("ATXP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nevskia ramosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122603.ATVI01000001_gene1836";
/// let this_library_node_name2 = "1122603.ATVI01000013_gene1403";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nevskia_ramosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_nevskia_ramosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nevskia_ramosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nevskia_ramosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122603"]),
        None,
        Some("."),
        Some("ATVI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nevskia soli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122604.JONR01000001_gene1677";
/// let this_library_node_name2 = "1122604.JONR01000089_gene3112";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nevskia_soli_node_name(this_library_node_name1));
/// assert!(is_valid_string_nevskia_soli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nevskia_soli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nevskia_soli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122604"]),
        None,
        Some("."),
        Some("JONR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Niabella aurantiaca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122605.KB893625_gene1544";
/// let this_library_node_name2 = "1122605.KB893649_gene3879";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_niabella_aurantiaca_node_name(this_library_node_name1));
/// assert!(is_valid_string_niabella_aurantiaca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_niabella_aurantiaca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_niabella_aurantiaca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122605"]),
        None,
        Some("."),
        Some("KB8936"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardioides halotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122609.AUGT01000001_gene2768";
/// let this_library_node_name2 = "1122609.AUGT01000035_gene2865";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardioides_halotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardioides_halotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardioides_halotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardioides_halotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122609"]),
        None,
        Some("."),
        Some("AUGT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nonomuraea coxensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122611.KB903939_gene255";
/// let this_library_node_name2 = "1122611.KB904038_gene6850";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nonomuraea_coxensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nonomuraea_coxensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nonomuraea_coxensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nonomuraea_coxensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122611"]),
        None,
        Some("."),
        Some("KB90"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novosphingobium acidiphilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122612.AUBA01000001_gene1130";
/// let this_library_node_name2 = "1122612.AUBA01000055_gene3150";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novosphingobium_acidiphilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_novosphingobium_acidiphilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novosphingobium_acidiphilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novosphingobium_acidiphilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122612"]),
        None,
        Some("."),
        Some("AUBA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanicaulis alexandrii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122613.ATUP01000001_gene1";
/// let this_library_node_name2 = "1122613.ATUP01000004_gene2409";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanicaulis_alexandrii_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanicaulis_alexandrii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanicaulis_alexandrii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanicaulis_alexandrii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122613"]),
        None,
        Some("."),
        Some("ATUP0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanicola nanhaiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122614.JHZF01000001_gene334";
/// let this_library_node_name2 = "1122614.JHZF01000020_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanicola_nanhaiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanicola_nanhaiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanicola_nanhaiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanicola_nanhaiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122614"]),
        None,
        Some("."),
        Some("JHZF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oligella ureolytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122619.KB892279_gene1609";
/// let this_library_node_name2 = "1122619.KB892376_gene1988";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oligella_ureolytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_oligella_ureolytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oligella_ureolytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oligella_ureolytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122619"]),
        None,
        Some("."),
        Some("KB892"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Olivibacter sitiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122621.ATZA01000001_gene1884";
/// let this_library_node_name2 = "1122621.ATZA01000112_gene4044";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_olivibacter_sitiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_olivibacter_sitiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_olivibacter_sitiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_olivibacter_sitiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122621"]),
        None,
        Some("."),
        Some("ATZA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ornithinimicrobium pekingense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122622.ATWJ01000001_gene2377";
/// let this_library_node_name2 = "1122622.ATWJ01000015_gene712";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ornithinimicrobium_pekingense_node_name(this_library_node_name1));
/// assert!(is_valid_string_ornithinimicrobium_pekingense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ornithinimicrobium_pekingense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ornithinimicrobium_pekingense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122622"]),
        None,
        Some("."),
        Some("ATWJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus alginolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122915.AUGY01000001_gene6900";
/// let this_library_node_name2 = "1122915.AUGY01000224_gene1908";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_alginolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_alginolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_alginolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_alginolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122915"]),
        None,
        Some("."),
        Some("AUGY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus daejeonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122917.KB899659_gene4813";
/// let this_library_node_name2 = "1122917.KB899694_gene2817";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_daejeonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_daejeonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_daejeonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_daejeonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122917"]),
        None,
        Some("."),
        Some("KB8996"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus fonticola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122918.KB907245_gene4985";
/// let this_library_node_name2 = "1122918.KB907306_gene1553";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_fonticola_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_fonticola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_fonticola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_fonticola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122918"]),
        None,
        Some("."),
        Some("KB907"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus ginsengihumi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122919.KB905548_gene2182";
/// let this_library_node_name2 = "1122919.KB905691_gene3097";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_ginsengihumi_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_ginsengihumi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_ginsengihumi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_ginsengihumi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122919"]),
        None,
        Some("."),
        Some("KB905"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122921.KB898185_gene3565";
/// let this_library_node_name2 = "1122921.KB898220_gene5237";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122921"]),
        None,
        Some("."),
        Some("KB898"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sanguinis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122925.KB895376_gene333";
/// let this_library_node_name2 = "1122925.KB895411_gene1831";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sanguinis_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sanguinis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sanguinis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sanguinis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122925"]),
        None,
        Some("."),
        Some("KB895"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus terrigena nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122927.KB895412_gene1000";
/// let this_library_node_name2 = "1122927.KB895451_gene485";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_terrigena_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_terrigena_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_terrigena_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_terrigena_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122927"]),
        None,
        Some("."),
        Some("KB8954"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pannonibacter phragmitetus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122929.KB908215_gene1000";
/// let this_library_node_name2 = "1122929.KB908254_gene2959";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pannonibacter_phragmitetus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pannonibacter_phragmitetus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pannonibacter_phragmitetus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pannonibacter_phragmitetus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122929"]),
        None,
        Some("."),
        Some("KB9082"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parabacteroides gordonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122931.AUAE01000001_gene487";
/// let this_library_node_name2 = "1122931.AUAE01000062_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parabacteroides_gordonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_parabacteroides_gordonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parabacteroides_gordonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parabacteroides_gordonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122931"]),
        None,
        Some("."),
        Some("AUAE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paraoerskovia marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122933.JNIY01000003_gene1";
/// let this_library_node_name2 = "1122933.JNIY01000013_gene1315";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paraoerskovia_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_paraoerskovia_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paraoerskovia_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paraoerskovia_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122933"]),
        None,
        Some("."),
        Some("JNIY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Patulibacter americanus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122939.ATUD01000001_gene1";
/// let this_library_node_name2 = "1122939.ATUD01000032_gene2807";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_patulibacter_americanus_node_name(this_library_node_name1));
/// assert!(is_valid_string_patulibacter_americanus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_patulibacter_americanus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_patulibacter_americanus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122939"]),
        None,
        Some("."),
        Some("ATUD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelosinus fermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122947.FR7_0001";
/// let this_library_node_name2 = "1122947.FR7_4597";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelosinus_fermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelosinus_fermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelosinus_fermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelosinus_fermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122947"]),
        None,
        Some("."),
        Some("FR7_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Perlucidibaca piscinae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122951.ATUE01000001_gene523";
/// let this_library_node_name2 = "1122951.ATUE01000013_gene1519";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_perlucidibaca_piscinae_node_name(this_library_node_name1));
/// assert!(is_valid_string_perlucidibaca_piscinae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_perlucidibaca_piscinae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_perlucidibaca_piscinae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122951"]),
        None,
        Some("."),
        Some("ATUE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pleomorphomonas koreensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122962.AULH01000001_gene1372";
/// let this_library_node_name2 = "1122962.AULH01000074_gene3714";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pleomorphomonas_koreensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pleomorphomonas_koreensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pleomorphomonas_koreensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pleomorphomonas_koreensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122962"]),
        None,
        Some("."),
        Some("AULH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pleomorphomonas oryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122963.AUHB01000001_gene148";
/// let this_library_node_name2 = "1122963.AUHB01000038_gene130";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pleomorphomonas_oryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_pleomorphomonas_oryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pleomorphomonas_oryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pleomorphomonas_oryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122963"]),
        None,
        Some("."),
        Some("AUHB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyrobacter cryptus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122970.AUHC01000001_gene333";
/// let this_library_node_name2 = "1122970.AUHC01000036_gene1678";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyrobacter_cryptus_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyrobacter_cryptus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyrobacter_cryptus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyrobacter_cryptus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122970"]),
        None,
        Some("."),
        Some("AUHC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas bennonis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122971.BAME01000001_gene1";
/// let this_library_node_name2 = "1122971.BAME01000242_gene6817";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_bennonis_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_bennonis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_bennonis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_bennonis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122971"]),
        None,
        Some("."),
        Some("BAME01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas levii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122973.KB904203_gene1828";
/// let this_library_node_name2 = "1122973.KB904326_gene159";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_levii_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_levii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_levii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_levii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122973"]),
        None,
        Some("."),
        Some("KB904"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas somerae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122975.AQVC01000001_gene418";
/// let this_library_node_name2 = "1122975.AQVC01000094_gene1071";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_somerae_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_somerae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_somerae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_somerae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122975"]),
        None,
        Some("."),
        Some("AQVC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella albensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122978.AUFP01000001_gene1000";
/// let this_library_node_name2 = "1122978.AUFP01000048_gene706";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_albensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_albensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_albensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_albensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122978"]),
        None,
        Some("."),
        Some("AUFP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella corporis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122981.AUME01000001_gene1740";
/// let this_library_node_name2 = "1122981.AUME01000092_gene1571";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_corporis_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_corporis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_corporis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_corporis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122981"]),
        None,
        Some("."),
        Some("AUME010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella falsenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122983.BAJY01000001_gene100";
/// let this_library_node_name2 = "1122983.BAJY01000092_gene429";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_falsenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_falsenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_falsenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_falsenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122983"]),
        None,
        Some("."),
        Some("BAJY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella loescheii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122985.HMPREF1991_00001";
/// let this_library_node_name2 = "1122985.HMPREF1991_03283";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_loescheii_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_loescheii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_loescheii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_loescheii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122985"]),
        None,
        Some("."),
        Some("HMPREF1991_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella maculosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122986.KB908319_gene100";
/// let this_library_node_name2 = "1122986.KB908377_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_maculosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_maculosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_maculosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_maculosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122986"]),
        None,
        Some("."),
        Some("KB9083"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella oris DSM18711 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122989.KB898577_gene100";
/// let this_library_node_name2 = "1122989.KB898622_gene32";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_oris_dsm18711_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_oris_dsm18711_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_oris_dsm18711_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_oris_dsm18711_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122989"]),
        None,
        Some("."),
        Some("KB898"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella paludivivens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122990.BAJH01000001_gene1";
/// let this_library_node_name2 = "1122990.BAJH01000097_gene2910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_paludivivens_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_paludivivens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_paludivivens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_paludivivens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122990"]),
        None,
        Some("."),
        Some("BAJH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella shahii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122991.BAIZ01000001_gene1";
/// let this_library_node_name2 = "1122991.BAIZ01000142_gene3049";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_shahii_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_shahii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_shahii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_shahii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122991"]),
        None,
        Some("."),
        Some("BAIZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella timonensis 4401737 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122992.CBQQ010000001_gene2468";
/// let this_library_node_name2 = "1122992.CBQQ010000101_gene958";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_timonensis_4401737_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_timonensis_4401737_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_timonensis_4401737_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_timonensis_4401737_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122992"]),
        None,
        Some("."),
        Some("CBQQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella veroralis DSM19559 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122993.KB898325_gene1852";
/// let this_library_node_name2 = "1122993.KB898352_gene110";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_veroralis_dsm19559_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_veroralis_dsm19559_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_veroralis_dsm19559_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_veroralis_dsm19559_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122993"]),
        None,
        Some("."),
        Some("KB8983"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium acidifaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122994.AUFR01000001_gene1332";
/// let this_library_node_name2 = "1122994.AUFR01000087_gene1211";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_acidifaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_acidifaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_acidifaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_acidifaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122994"]),
        None,
        Some("."),
        Some("AUFR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium jensenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122997.AUDD01000001_gene2361";
/// let this_library_node_name2 = "1122997.AUDD01000056_gene2034";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_jensenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_jensenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_jensenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_jensenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122997"]),
        None,
        Some("."),
        Some("AUDD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium thoenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1122998.AUHZ01000001_gene1790";
/// let this_library_node_name2 = "1122998.AUHZ01000046_gene605";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_thoenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_thoenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_thoenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_thoenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1122998"]),
        None,
        Some("."),
        Some("AUHZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Proteiniphilum acetatigenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123008.KB905692_gene1";
/// let this_library_node_name2 = "1123008.KB905728_gene3660";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_proteiniphilum_acetatigenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_proteiniphilum_acetatigenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_proteiniphilum_acetatigenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_proteiniphilum_acetatigenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123008"]),
        None,
        Some("."),
        Some("KB905"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Proteocatella sphenisci nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123009.AUID01000001_gene1005";
/// let this_library_node_name2 = "1123009.AUID01000047_gene1200";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_proteocatella_sphenisci_node_name(this_library_node_name1));
/// assert!(is_valid_string_proteocatella_sphenisci_node_name(this_library_node_name2));
/// assert!(!is_valid_string_proteocatella_sphenisci_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_proteocatella_sphenisci_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123009"]),
        None,
        Some("."),
        Some("AUID010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoclavibacter soli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123013.AUIC01000001_gene100";
/// let this_library_node_name2 = "1123013.AUIC01000010_gene144";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoclavibacter_soli_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoclavibacter_soli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoclavibacter_soli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoclavibacter_soli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123013"]),
        None,
        Some("."),
        Some("AUIC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas resinovorans DSM21078 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123020.AUIE01000001_gene1998";
/// let this_library_node_name2 = "1123020.AUIE01000058_gene1766";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_resinovorans_dsm21078_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_resinovorans_dsm21078_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_resinovorans_dsm21078_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_resinovorans_dsm21078_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123020"]),
        None,
        Some("."),
        Some("AUIE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudonocardia acaciae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123023.JIAI01000001_gene5916";
/// let this_library_node_name2 = "1123023.JIAI01000095_gene7811";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudonocardia_acaciae_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudonocardia_acaciae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudonocardia_acaciae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudonocardia_acaciae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123023"]),
        None,
        Some("."),
        Some("JIAI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudonocardia asaccharolytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123024.AUII01000001_gene2715";
/// let this_library_node_name2 = "1123024.AUII01000074_gene4070";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudonocardia_asaccharolytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudonocardia_asaccharolytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudonocardia_asaccharolytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudonocardia_asaccharolytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123024"]),
        None,
        Some("."),
        Some("AUII010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter lutiphocae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123033.ARNF01000001_gene2309";
/// let this_library_node_name2 = "1123033.ARNF01000089_gene1243";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_lutiphocae_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_lutiphocae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_lutiphocae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_lutiphocae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123033"]),
        None,
        Some("."),
        Some("ARNF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter phenylpyruvicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123034.JMKP01000001_gene1939";
/// let this_library_node_name2 = "1123034.JMKP01000106_gene1093";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_phenylpyruvicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_phenylpyruvicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_phenylpyruvicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_phenylpyruvicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123034"]),
        None,
        Some("."),
        Some("JMKP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychroflexus tropicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123035.ARLA01000001_gene627";
/// let this_library_node_name2 = "1123035.ARLA01000028_gene2635";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychroflexus_tropicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychroflexus_tropicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychroflexus_tropicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychroflexus_tropicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123035"]),
        None,
        Some("."),
        Some("ARLA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychroserpens burtonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123037.AUDE01000001_gene1672";
/// let this_library_node_name2 = "1123037.AUDE01000073_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychroserpens_burtonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychroserpens_burtonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychroserpens_burtonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychroserpens_burtonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123037"]),
        None,
        Some("."),
        Some("AUDE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rathayibacter toxicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123052.AUDF01000001_gene1659";
/// let this_library_node_name2 = "1123052.AUDF01000031_gene1726";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rathayibacter_toxicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rathayibacter_toxicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rathayibacter_toxicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rathayibacter_toxicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123052"]),
        None,
        Some("."),
        Some("AUDF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rheinheimera baltica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123053.AUDG01000001_gene2292";
/// let this_library_node_name2 = "1123053.AUDG01000136_gene2229";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rheinheimera_baltica_node_name(this_library_node_name1));
/// assert!(is_valid_string_rheinheimera_baltica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rheinheimera_baltica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rheinheimera_baltica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123053"]),
        None,
        Some("."),
        Some("AUDG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rheinheimera perlucida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123054.KB907701_gene1694";
/// let this_library_node_name2 = "1123054.KB907782_gene3406";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rheinheimera_perlucida_node_name(this_library_node_name1));
/// assert!(is_valid_string_rheinheimera_perlucida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rheinheimera_perlucida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rheinheimera_perlucida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123054"]),
        None,
        Some("."),
        Some("KB9077"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodonellum psychrophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123057.P872_00005";
/// let this_library_node_name2 = "1123057.P872_25550";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodonellum_psychrophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodonellum_psychrophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodonellum_psychrophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodonellum_psychrophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123057"]),
        None,
        Some("."),
        Some("P872_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Riemerella columbina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123058.KB894217_gene423";
/// let this_library_node_name2 = "1123058.KB894283_gene1623";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_riemerella_columbina_node_name(this_library_node_name1));
/// assert!(is_valid_string_riemerella_columbina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_riemerella_columbina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_riemerella_columbina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123058"]),
        None,
        Some("."),
        Some("KB8942"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Robiginitomaculum antarcticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123059.KB823011_gene1000";
/// let this_library_node_name2 = "1123059.KB823015_gene2538";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_robiginitomaculum_antarcticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_robiginitomaculum_antarcticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_robiginitomaculum_antarcticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_robiginitomaculum_antarcticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123059"]),
        None,
        Some("."),
        Some("KB82301"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseomonas aerilata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123060.JONP01000001_gene1168";
/// let this_library_node_name2 = "1123060.JONP01000151_gene3322";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseomonas_aerilata_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseomonas_aerilata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseomonas_aerilata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseomonas_aerilata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123060"]),
        None,
        Some("."),
        Some("JONP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruania albidiflava nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123065.ATWL01000001_gene129";
/// let this_library_node_name2 = "1123065.ATWL01000060_gene2541";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruania_albidiflava_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruania_albidiflava_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruania_albidiflava_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruania_albidiflava_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123065"]),
        None,
        Some("."),
        Some("ATWL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rubritalea marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123070.KB899247_gene1419";
/// let this_library_node_name2 = "1123070.KB899275_gene2443";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rubritalea_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_rubritalea_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rubritalea_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rubritalea_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123070"]),
        None,
        Some("."),
        Some("KB8992"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rubritepida flocculans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123072.AUDH01000001_gene2714";
/// let this_library_node_name2 = "1123072.AUDH01000074_gene2008";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rubritepida_flocculans_node_name(this_library_node_name1));
/// assert!(is_valid_string_rubritepida_flocculans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rubritepida_flocculans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rubritepida_flocculans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123072"]),
        None,
        Some("."),
        Some("AUDH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rudaea cellulosilytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123073.KB899241_gene1712";
/// let this_library_node_name2 = "1123073.KB899246_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rudaea_cellulosilytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_rudaea_cellulosilytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rudaea_cellulosilytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rudaea_cellulosilytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123073"]),
        None,
        Some("."),
        Some("KB89924"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus gauvreauii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123075.AUDP01000001_gene2213";
/// let this_library_node_name2 = "1123075.AUDP01000071_gene1130";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_gauvreauii_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_gauvreauii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_gauvreauii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_gauvreauii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123075"]),
        None,
        Some("."),
        Some("AUDP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharibacillus kuerlensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123226.KB899277_gene1119";
/// let this_library_node_name2 = "1123226.KB899331_gene2366";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharibacillus_kuerlensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharibacillus_kuerlensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharibacillus_kuerlensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharibacillus_kuerlensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123226"]),
        None,
        Some("."),
        Some("KB899"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharibacter floricola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123227.KB899333_gene457";
/// let this_library_node_name2 = "1123227.KB899375_gene781";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharibacter_floricola_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharibacter_floricola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharibacter_floricola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharibacter_floricola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123227"]),
        None,
        Some("."),
        Some("KB8993"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharospirillum impatiens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123228.AUIH01000001_gene1176";
/// let this_library_node_name2 = "1123228.AUIH01000153_gene4048";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharospirillum_impatiens_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharospirillum_impatiens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharospirillum_impatiens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharospirillum_impatiens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123228"]),
        None,
        Some("."),
        Some("AUIH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinarimonas rosea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123229.AUBC01000001_gene1420";
/// let this_library_node_name2 = "1123229.AUBC01000057_gene3507";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinarimonas_rosea_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinarimonas_rosea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinarimonas_rosea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinarimonas_rosea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123229"]),
        None,
        Some("."),
        Some("AUBC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinicoccus albus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123230.ARQJ01000001_gene1096";
/// let this_library_node_name2 = "1123230.ARQJ01000033_gene1879";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinicoccus_albus_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinicoccus_albus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinicoccus_albus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinicoccus_albus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123230"]),
        None,
        Some("."),
        Some("ARQJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinimicrobium terrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123234.AUKI01000001_gene1822";
/// let this_library_node_name2 = "1123234.AUKI01000024_gene2189";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinimicrobium_terrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinimicrobium_terrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinimicrobium_terrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinimicrobium_terrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123234"]),
        None,
        Some("."),
        Some("AUKI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinimonas chungwhensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123236.KB899376_gene1000";
/// let this_library_node_name2 = "1123236.KB899405_gene2753";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinimonas_chungwhensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinimonas_chungwhensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinimonas_chungwhensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinimonas_chungwhensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123236"]),
        None,
        Some("."),
        Some("KB899"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salipiger mucosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123237.Salmuc_00001";
/// let this_library_node_name2 = "1123237.Salmuc_05706";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salipiger_mucosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_salipiger_mucosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salipiger_mucosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salipiger_mucosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123237"]),
        None,
        Some("."),
        Some("Salmuc_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salsuginibacillus kocurii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123239.KB898623_gene1000";
/// let this_library_node_name2 = "1123239.KB898645_gene25";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salsuginibacillus_kocurii_node_name(this_library_node_name1));
/// assert!(is_valid_string_salsuginibacillus_kocurii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salsuginibacillus_kocurii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salsuginibacillus_kocurii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123239"]),
        None,
        Some("."),
        Some("KB8986"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sandarakinorhabdus limnophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123240.ATVO01000003_gene1";
/// let this_library_node_name2 = "1123240.ATVO01000011_gene606";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sandarakinorhabdus_limnophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_sandarakinorhabdus_limnophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sandarakinorhabdus_limnophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sandarakinorhabdus_limnophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123240"]),
        None,
        Some("."),
        Some("ATVO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Schlesneria paludicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123242.JH636434_gene3152";
/// let this_library_node_name2 = "1123242.JH636438_gene5903";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_schlesneria_paludicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_schlesneria_paludicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_schlesneria_paludicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_schlesneria_paludicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123242"]),
        None,
        Some("."),
        Some("JH63643"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sediminimonas qiaohouensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123247.AUIJ01000001_gene1409";
/// let this_library_node_name2 = "1123247.AUIJ01000068_gene2763";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sediminimonas_qiaohouensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sediminimonas_qiaohouensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sediminimonas_qiaohouensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sediminimonas_qiaohouensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123247"]),
        None,
        Some("."),
        Some("AUIJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Segetibacter koreensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123248.KB893314_gene3257";
/// let this_library_node_name2 = "1123248.KB893386_gene1987";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_segetibacter_koreensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_segetibacter_koreensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_segetibacter_koreensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_segetibacter_koreensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123248"]),
        None,
        Some("."),
        Some("KB8933"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas bovis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123250.KB908379_gene1000";
/// let this_library_node_name2 = "1123250.KB908453_gene78";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_bovis_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_bovis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_bovis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_bovis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123250"]),
        None,
        Some("."),
        Some("KB908"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serinicoccus marinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123251.ATWM01000001_gene484";
/// let this_library_node_name2 = "1123251.ATWM01000028_gene1477";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serinicoccus_marinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_serinicoccus_marinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serinicoccus_marinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serinicoccus_marinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123251"]),
        None,
        Some("."),
        Some("ATWM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shimazuella kribbensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123252.ATZF01000001_gene1000";
/// let this_library_node_name2 = "1123252.ATZF01000046_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shimazuella_kribbensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_shimazuella_kribbensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shimazuella_kribbensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shimazuella_kribbensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123252"]),
        None,
        Some("."),
        Some("ATZF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Silanimonas lenta nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123253.AUBD01000001_gene1449";
/// let this_library_node_name2 = "1123253.AUBD01000023_gene2013";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_silanimonas_lenta_node_name(this_library_node_name1));
/// assert!(is_valid_string_silanimonas_lenta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_silanimonas_lenta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_silanimonas_lenta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123253"]),
        None,
        Some("."),
        Some("AUBD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Simplicispira psychrophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123255.JHYS01000001_gene1829";
/// let this_library_node_name2 = "1123255.JHYS01000038_gene206";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_simplicispira_psychrophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_simplicispira_psychrophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_simplicispira_psychrophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_simplicispira_psychrophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123255"]),
        None,
        Some("."),
        Some("JHYS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solimonas variicoloris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123256.KB907925_gene1042";
/// let this_library_node_name2 = "1123256.KB907972_gene3203";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solimonas_variicoloris_node_name(this_library_node_name1));
/// assert!(is_valid_string_solimonas_variicoloris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solimonas_variicoloris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solimonas_variicoloris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123256"]),
        None,
        Some("."),
        Some("KB9079"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solimonas flava nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123257.AUFV01000001_gene1465";
/// let this_library_node_name2 = "1123257.AUFV01000027_gene1986";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solimonas_flava_node_name(this_library_node_name1));
/// assert!(is_valid_string_solimonas_flava_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solimonas_flava_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solimonas_flava_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123257"]),
        None,
        Some("."),
        Some("AUFV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Smaragdicoccus niigatensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123258.AQXZ01000001_gene1689";
/// let this_library_node_name2 = "1123258.AQXZ01000019_gene3637";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_smaragdicoccus_niigatensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_smaragdicoccus_niigatensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_smaragdicoccus_niigatensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_smaragdicoccus_niigatensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123258"]),
        None,
        Some("."),
        Some("AQXZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solimonas soli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123261.AXDW01000001_gene1000";
/// let this_library_node_name2 = "1123261.AXDW01000041_gene3641";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solimonas_soli_node_name(this_library_node_name1));
/// assert!(is_valid_string_solimonas_soli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solimonas_soli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solimonas_soli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123261"]),
        None,
        Some("."),
        Some("AXDW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solobacterium moorei DSM22971 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123263.AUKY01000001_gene122";
/// let this_library_node_name2 = "1123263.AUKY01000170_gene2056";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solobacterium_moorei_dsm22971_node_name(this_library_node_name1));
/// assert!(is_valid_string_solobacterium_moorei_dsm22971_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solobacterium_moorei_dsm22971_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solobacterium_moorei_dsm22971_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123263"]),
        None,
        Some("."),
        Some("AUKY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas astaxanthinifaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123267.JONN01000001_gene1000";
/// let this_library_node_name2 = "1123267.JONN01000003_gene369";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_astaxanthinifaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_astaxanthinifaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_astaxanthinifaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_astaxanthinifaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123267"]),
        None,
        Some("."),
        Some("JONN0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sanxanigenens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123269.NX02_00005";
/// let this_library_node_name2 = "1123269.NX02_29775";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sanxanigenens_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sanxanigenens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sanxanigenens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sanxanigenens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123269"]),
        None,
        Some("."),
        Some("NX02_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingopyxis baekryungensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123270.ATUR01000001_gene2743";
/// let this_library_node_name2 = "1123270.ATUR01000010_gene1959";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingopyxis_baekryungensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingopyxis_baekryungensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingopyxis_baekryungensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingopyxis_baekryungensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123270"]),
        None,
        Some("."),
        Some("ATUR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirochaeta bajacaliforniensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123274.KB899406_gene1000";
/// let this_library_node_name2 = "1123274.KB899475_gene642";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirochaeta_bajacaliforniensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirochaeta_bajacaliforniensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirochaeta_bajacaliforniensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirochaeta_bajacaliforniensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123274"]),
        None,
        Some("."),
        Some("KB8994"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirosoma luteum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123276.KB893245_gene1000";
/// let this_library_node_name2 = "1123276.KB893313_gene3947";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirosoma_luteum_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirosoma_luteum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirosoma_luteum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirosoma_luteum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123276"]),
        None,
        Some("."),
        Some("KB893"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirosoma panaciterrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123277.KB893172_gene1000";
/// let this_library_node_name2 = "1123277.KB893244_gene5196";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirosoma_panaciterrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirosoma_panaciterrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirosoma_panaciterrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirosoma_panaciterrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123277"]),
        None,
        Some("."),
        Some("KB893"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirosoma spitsbergense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123278.KB893387_gene4249";
/// let this_library_node_name2 = "1123278.KB893624_gene3218";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirosoma_spitsbergense_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirosoma_spitsbergense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirosoma_spitsbergense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirosoma_spitsbergense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123278"]),
        None,
        Some("."),
        Some("KB893"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spongiibacter tropicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123279.ATUS01000001_gene1000";
/// let this_library_node_name2 = "1123279.ATUS01000007_gene3080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spongiibacter_tropicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_spongiibacter_tropicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spongiibacter_tropicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spongiibacter_tropicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123279"]),
        None,
        Some("."),
        Some("ATUS0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporolactobacillus vineae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123284.KB899042_gene1059";
/// let this_library_node_name2 = "1123284.KB899086_gene1057";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporolactobacillus_vineae_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporolactobacillus_vineae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporolactobacillus_vineae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporolactobacillus_vineae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123284"]),
        None,
        Some("."),
        Some("KB8990"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporomusa ovata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123288.SOV_1c00020";
/// let this_library_node_name2 = "1123288.SOV_8c00030";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporomusa_ovata_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporomusa_ovata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporomusa_ovata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporomusa_ovata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123288"]),
        None,
        Some("."),
        Some("SOV_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporosarcina ureae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123290.AUDQ01000001_gene2534";
/// let this_library_node_name2 = "1123290.AUDQ01000036_gene680";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporosarcina_ureae_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporosarcina_ureae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporosarcina_ureae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporosarcina_ureae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123290"]),
        None,
        Some("."),
        Some("AUDQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stenoxybacter acetivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123296.JQKE01000001_gene1183";
/// let this_library_node_name2 = "1123296.JQKE01000151_gene144";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stenoxybacter_acetivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_stenoxybacter_acetivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stenoxybacter_acetivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stenoxybacter_acetivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123296"]),
        None,
        Some("."),
        Some("JQKE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus caballi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123298.KB904062_gene740";
/// let this_library_node_name2 = "1123298.KB904123_gene2009";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_caballi_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_caballi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_caballi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_caballi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123298"]),
        None,
        Some("."),
        Some("KB904"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus castoreus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123299.AUKZ01000001_gene100";
/// let this_library_node_name2 = "1123299.AUKZ01000045_gene1524";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_castoreus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_castoreus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_castoreus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_castoreus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123299"]),
        None,
        Some("."),
        Some("AUKZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus devriesei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123300.AUIN01000001_gene556";
/// let this_library_node_name2 = "1123300.AUIN01000021_gene772";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_devriesei_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_devriesei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_devriesei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_devriesei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123300"]),
        None,
        Some("."),
        Some("AUIN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus didelphis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123301.KB904188_gene1000";
/// let this_library_node_name2 = "1123301.KB904202_gene1811";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_didelphis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_didelphis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_didelphis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_didelphis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123301"]),
        None,
        Some("."),
        Some("KB904"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus entericus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123302.KB904155_gene1644";
/// let this_library_node_name2 = "1123302.KB904187_gene920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_entericus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_entericus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_entericus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_entericus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123302"]),
        None,
        Some("."),
        Some("KB9041"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus ferus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123303.AQVD01000001_gene414";
/// let this_library_node_name2 = "1123303.AQVD01000012_gene1808";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_ferus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_ferus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_ferus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_ferus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123303"]),
        None,
        Some("."),
        Some("AQVD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus henryi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123304.AQYA01000001_gene1";
/// let this_library_node_name2 = "1123304.AQYA01000037_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_henryi_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_henryi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_henryi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_henryi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123304"]),
        None,
        Some("."),
        Some("AQYA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus marimammalium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123306.KB904339_gene100";
/// let this_library_node_name2 = "1123306.KB904363_gene1169";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_marimammalium_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_marimammalium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_marimammalium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_marimammalium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123306"]),
        None,
        Some("."),
        Some("KB9043"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123307.KB904364_gene1142";
/// let this_library_node_name2 = "1123307.KB904447_gene849";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123307"]),
        None,
        Some("."),
        Some("KB904"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus merionis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123308.KB904538_gene10";
/// let this_library_node_name2 = "1123308.KB904561_gene2022";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_merionis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_merionis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_merionis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_merionis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123308"]),
        None,
        Some("."),
        Some("KB9045"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus minor nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123309.AQYB01000001_gene443";
/// let this_library_node_name2 = "1123309.AQYB01000033_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_minor_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_minor_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_minor_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_minor_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123309"]),
        None,
        Some("."),
        Some("AQYB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus orisratti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123311.KB904448_gene1";
/// let this_library_node_name2 = "1123311.KB904537_gene2078";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_orisratti_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_orisratti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_orisratti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_orisratti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123311"]),
        None,
        Some("."),
        Some("KB904"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus ovis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123312.KB904562_gene1551";
/// let this_library_node_name2 = "1123312.KB904585_gene847";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_ovis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_ovis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_ovis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_ovis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123312"]),
        None,
        Some("."),
        Some("KB9045"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Faecalicoccus pleomorphus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123313.ATUT01000001_gene1000";
/// let this_library_node_name2 = "1123313.ATUT01000046_gene394";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_faecalicoccus_pleomorphus_node_name(this_library_node_name1));
/// assert!(is_valid_string_faecalicoccus_pleomorphus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_faecalicoccus_pleomorphus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_faecalicoccus_pleomorphus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123313"]),
        None,
        Some("."),
        Some("ATUT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus plurextorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123314.AUIO01000001_gene1332";
/// let this_library_node_name2 = "1123314.AUIO01000036_gene304";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_plurextorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_plurextorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_plurextorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_plurextorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123314"]),
        None,
        Some("."),
        Some("AUIO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus porci nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123315.AUIP01000001_gene1401";
/// let this_library_node_name2 = "1123315.AUIP01000037_gene258";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_porci_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_porci_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_porci_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_porci_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123315"]),
        None,
        Some("."),
        Some("AUIP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus thoraltensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123318.KB904586_gene287";
/// let this_library_node_name2 = "1123318.KB904633_gene1326";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_thoraltensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_thoraltensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_thoraltensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_thoraltensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123318"]),
        None,
        Some("."),
        Some("KB904"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces flavidovirens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123319.AUBE01000001_gene1640";
/// let this_library_node_name2 = "1123319.AUBE01000049_gene3026";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_flavidovirens_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_flavidovirens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_flavidovirens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_flavidovirens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123319"]),
        None,
        Some("."),
        Some("AUBE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces scabrisporus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123320.KB889561_gene4552";
/// let this_library_node_name2 = "1123320.KB889751_gene8834";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_scabrisporus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_scabrisporus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_scabrisporus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_scabrisporus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123320"]),
        None,
        Some("."),
        Some("KB889"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sulphureus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123321.KB905813_gene1000";
/// let this_library_node_name2 = "1123321.KB905838_gene2362";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sulphureus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sulphureus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sulphureus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sulphureus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123321"]),
        None,
        Some("."),
        Some("KB9058"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces vitaminophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123322.KB904634_gene2169";
/// let this_library_node_name2 = "1123322.KB904745_gene3426";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_vitaminophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_vitaminophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_vitaminophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_vitaminophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123322"]),
        None,
        Some("."),
        Some("KB904"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurihydrogenibium subterraneum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123325.JHUV01000001_gene100";
/// let this_library_node_name2 = "1123325.JHUV01000017_gene222";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurihydrogenibium_subterraneum_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurihydrogenibium_subterraneum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurihydrogenibium_subterraneum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurihydrogenibium_subterraneum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123325"]),
        None,
        Some("."),
        Some("JHUV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurospirillum arcachonense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123326.JFBL01000001_gene1216";
/// let this_library_node_name2 = "1123326.JFBL01000042_gene2276";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurospirillum_arcachonense_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurospirillum_arcachonense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurospirillum_arcachonense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurospirillum_arcachonense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123326"]),
        None,
        Some("."),
        Some("JFBL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tepidiphilus margaritifer nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123354.AUDR01000001_gene2014";
/// let this_library_node_name2 = "1123354.AUDR01000020_gene2011";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tepidiphilus_margaritifer_node_name(this_library_node_name1));
/// assert!(is_valid_string_tepidiphilus_margaritifer_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tepidiphilus_margaritifer_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tepidiphilus_margaritifer_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123354"]),
        None,
        Some("."),
        Some("AUDR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Terasakiella pusilla nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123355.JHYO01000001_gene3131";
/// let this_library_node_name2 = "1123355.JHYO01000085_gene1202";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_terasakiella_pusilla_node_name(this_library_node_name1));
/// assert!(is_valid_string_terasakiella_pusilla_node_name(this_library_node_name2));
/// assert!(!is_valid_string_terasakiella_pusilla_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_terasakiella_pusilla_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123355"]),
        None,
        Some("."),
        Some("JHYO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tetragenococcus muriaticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123359.AUIQ01000001_gene1876";
/// let this_library_node_name2 = "1123359.AUIQ01000111_gene594";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tetragenococcus_muriaticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_tetragenococcus_muriaticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tetragenococcus_muriaticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tetragenococcus_muriaticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123359"]),
        None,
        Some("."),
        Some("AUIQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thalassobacter arenae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123360.thalar_00001";
/// let this_library_node_name2 = "1123360.thalar_03688";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thalassobacter_arenae_node_name(this_library_node_name1));
/// assert!(is_valid_string_thalassobacter_arenae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thalassobacter_arenae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thalassobacter_arenae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123360"]),
        None,
        Some("."),
        Some("thalar_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thalassospira xiamenensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123366.TH3_00005";
/// let this_library_node_name2 = "1123366.TH3_21857";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thalassospira_xiamenensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thalassospira_xiamenensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thalassospira_xiamenensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thalassospira_xiamenensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123366"]),
        None,
        Some("."),
        Some("TH3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thauera linaloolentis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123367.C666_00005";
/// let this_library_node_name2 = "1123367.C666_19235";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thauera_linaloolentis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thauera_linaloolentis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thauera_linaloolentis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thauera_linaloolentis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123367"]),
        None,
        Some("."),
        Some("C666_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermithiobacillus tepidarius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123368.AUIS01000001_gene1847";
/// let this_library_node_name2 = "1123368.AUIS01000044_gene18";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermithiobacillus_tepidarius_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermithiobacillus_tepidarius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermithiobacillus_tepidarius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermithiobacillus_tepidarius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123368"]),
        None,
        Some("."),
        Some("AUIS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermodesulfatator atlanticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123371.ATXH01000001_gene1173";
/// let this_library_node_name2 = "1123371.ATXH01000060_gene404";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermodesulfatator_atlanticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermodesulfatator_atlanticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermodesulfatator_atlanticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermodesulfatator_atlanticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123371"]),
        None,
        Some("."),
        Some("ATXH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermodesulfobacterium hveragerdense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123372.AUIT01000001_gene621";
/// let this_library_node_name2 = "1123372.AUIT01000047_gene1698";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermodesulfobacterium_hveragerdense_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermodesulfobacterium_hveragerdense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermodesulfobacterium_hveragerdense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermodesulfobacterium_hveragerdense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123372"]),
        None,
        Some("."),
        Some("AUIT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermodesulfobacterium thermophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123373.ATXI01000001_gene412";
/// let this_library_node_name2 = "1123373.ATXI01000046_gene47";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermodesulfobacterium_thermophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermodesulfobacterium_thermophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermodesulfobacterium_thermophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermodesulfobacterium_thermophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123373"]),
        None,
        Some("."),
        Some("ATXI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermodesulfovibrio thiophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123376.AUIU01000001_gene750";
/// let this_library_node_name2 = "1123376.AUIU01000019_gene1313";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermodesulfovibrio_thiophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermodesulfovibrio_thiophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermodesulfovibrio_thiophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermodesulfovibrio_thiophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123376"]),
        None,
        Some("."),
        Some("AUIU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermomonas fusca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123377.AUIV01000001_gene1000";
/// let this_library_node_name2 = "1123377.AUIV01000054_gene1471";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermomonas_fusca_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermomonas_fusca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermomonas_fusca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermomonas_fusca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123377"]),
        None,
        Some("."),
        Some("AUIV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus antranikianii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123386.AUIW01000001_gene144";
/// let this_library_node_name2 = "1123386.AUIW01000034_gene59";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_antranikianii_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_antranikianii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_antranikianii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_antranikianii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123386"]),
        None,
        Some("."),
        Some("AUIW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus igniterrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123388.AQWU01000001_gene1434";
/// let this_library_node_name2 = "1123388.AQWU01000074_gene1304";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_igniterrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_igniterrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_igniterrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_igniterrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123388"]),
        None,
        Some("."),
        Some("AQWU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus islandicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123389.ATXJ01000001_gene439";
/// let this_library_node_name2 = "1123389.ATXJ01000067_gene153";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_islandicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_islandicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_islandicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_islandicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123389"]),
        None,
        Some("."),
        Some("ATXJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiobacillus denitrificans DSM12475 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123392.AQWL01000001_gene1279";
/// let this_library_node_name2 = "1123392.AQWL01000038_gene2135";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiobacillus_denitrificans_dsm12475_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiobacillus_denitrificans_dsm12475_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiobacillus_denitrificans_dsm12475_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiobacillus_denitrificans_dsm12475_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123392"]),
        None,
        Some("."),
        Some("AQWL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiobacillus thioparus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123393.KB891316_gene1075";
/// let this_library_node_name2 = "1123393.KB891333_gene2679";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiobacillus_thioparus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiobacillus_thioparus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiobacillus_thioparus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiobacillus_thioparus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123393"]),
        None,
        Some("."),
        Some("KB8913"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiothrix disciformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123399.AQVE01000001_gene459";
/// let this_library_node_name2 = "1123399.AQVE01000071_gene1393";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiothrix_disciformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiothrix_disciformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiothrix_disciformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiothrix_disciformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123399"]),
        None,
        Some("."),
        Some("AQVE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiothrix flexilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123400.KB904746_gene1129";
/// let this_library_node_name2 = "1123400.KB904817_gene1551";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiothrix_flexilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiothrix_flexilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiothrix_flexilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiothrix_flexilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123400"]),
        None,
        Some("."),
        Some("KB904"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiothrix lacustris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123401.JHYQ01000001_gene1695";
/// let this_library_node_name2 = "1123401.JHYQ01000055_gene1331";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiothrix_lacustris_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiothrix_lacustris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiothrix_lacustris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiothrix_lacustris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123401"]),
        None,
        Some("."),
        Some("JHYQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tuberibacillus calidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123405.AUMM01000001_gene1";
/// let this_library_node_name2 = "1123405.AUMM01000090_gene2507";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tuberibacillus_calidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_tuberibacillus_calidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tuberibacillus_calidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tuberibacillus_calidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123405"]),
        None,
        Some("."),
        Some("AUMM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Uliginosibacterium gangwonense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123487.KB892834_gene2573";
/// let this_library_node_name2 = "1123487.KB892868_gene1324";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_uliginosibacterium_gangwonense_node_name(this_library_node_name1));
/// assert!(is_valid_string_uliginosibacterium_gangwonense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_uliginosibacterium_gangwonense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_uliginosibacterium_gangwonense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123487"]),
        None,
        Some("."),
        Some("KB8928"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Varibaculum cambriense DSM15806 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123488.ATUF01000001_gene1";
/// let this_library_node_name2 = "1123488.ATUF01000010_gene1306";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_varibaculum_cambriense_dsm15806_node_name(this_library_node_name1));
/// assert!(is_valid_string_varibaculum_cambriense_dsm15806_node_name(this_library_node_name2));
/// assert!(!is_valid_string_varibaculum_cambriense_dsm15806_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_varibaculum_cambriense_dsm15806_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123488"]),
        None,
        Some("."),
        Some("ATUF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Veillonella magna nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123489.AUAN01000001_gene1278";
/// let this_library_node_name2 = "1123489.AUAN01000036_gene1110";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_veillonella_magna_node_name(this_library_node_name1));
/// assert!(is_valid_string_veillonella_magna_node_name(this_library_node_name2));
/// assert!(!is_valid_string_veillonella_magna_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_veillonella_magna_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123489"]),
        None,
        Some("."),
        Some("AUAN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vitreoscilla stercoraria nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123499.KB908018_gene1944";
/// let this_library_node_name2 = "1123499.KB908054_gene633";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vitreoscilla_stercoraria_node_name(this_library_node_name1));
/// assert!(is_valid_string_vitreoscilla_stercoraria_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vitreoscilla_stercoraria_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vitreoscilla_stercoraria_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123499"]),
        None,
        Some("."),
        Some("KB9080"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Weissella halotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123500.ATUU01000001_gene1";
/// let this_library_node_name2 = "1123500.ATUU01000006_gene1168";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_weissella_halotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_weissella_halotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_weissella_halotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_weissella_halotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123500"]),
        None,
        Some("."),
        Some("ATUU0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wenxinia marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123501.KB902276_gene1084";
/// let this_library_node_name2 = "1123501.KB902316_gene3112";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wenxinia_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_wenxinia_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wenxinia_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wenxinia_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123501"]),
        None,
        Some("."),
        Some("KB902"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wohlfahrtiimonas chitiniclastica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123502.AQXD01000001_gene1000";
/// let this_library_node_name2 = "1123502.AQXD01000007_gene1754";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wohlfahrtiimonas_chitiniclastica_node_name(this_library_node_name1));
/// assert!(is_valid_string_wohlfahrtiimonas_chitiniclastica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wohlfahrtiimonas_chitiniclastica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wohlfahrtiimonas_chitiniclastica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123502"]),
        None,
        Some("."),
        Some("AQXD0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Woodsholea maritima nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123503.KB908056_gene1226";
/// let this_library_node_name2 = "1123503.KB908075_gene1214";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_woodsholea_maritima_node_name(this_library_node_name1));
/// assert!(is_valid_string_woodsholea_maritima_node_name(this_library_node_name2));
/// assert!(!is_valid_string_woodsholea_maritima_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_woodsholea_maritima_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123503"]),
        None,
        Some("."),
        Some("KB9080"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xenophilus azovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123504.JQKD01000002_gene3544";
/// let this_library_node_name2 = "1123504.JQKD01000137_gene4701";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xenophilus_azovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_xenophilus_azovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xenophilus_azovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xenophilus_azovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123504"]),
        None,
        Some("."),
        Some("JQKD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yaniella halotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123507.ATVQ01000001_gene1000";
/// let this_library_node_name2 = "1123507.ATVQ01000005_gene91";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yaniella_halotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_yaniella_halotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yaniella_halotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yaniella_halotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123507"]),
        None,
        Some("."),
        Some("ATVQ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zavarzinella formosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123508.JH636439_gene1000";
/// let this_library_node_name2 = "1123508.JH636469_gene7060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zavarzinella_formosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_zavarzinella_formosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zavarzinella_formosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zavarzinella_formosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123508"]),
        None,
        Some("."),
        Some("JH6364"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zymophilus raffinosivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123511.KB905839_gene327";
/// let this_library_node_name2 = "1123511.KB905897_gene1826";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zymophilus_raffinosivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_zymophilus_raffinosivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zymophilus_raffinosivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zymophilus_raffinosivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123511"]),
        None,
        Some("."),
        Some("KB9058"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiomicrospira arctica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123514.KB905899_gene1000";
/// let this_library_node_name2 = "1123514.KB905904_gene426";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiomicrospira_arctica_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiomicrospira_arctica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiomicrospira_arctica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiomicrospira_arctica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123514"]),
        None,
        Some("."),
        Some("KB905"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiomicrospira pelophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123517.JOMR01000001_gene1";
/// let this_library_node_name2 = "1123517.JOMR01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiomicrospira_pelophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiomicrospira_pelophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiomicrospira_pelophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiomicrospira_pelophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123517"]),
        None,
        Some("."),
        Some("JOMR01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiomicrospira sp. Kp2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123518.ARWI01000001_gene1";
/// let this_library_node_name2 = "1123518.ARWI01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiomicrospira_sp_kp2_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiomicrospira_sp_kp2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiomicrospira_sp_kp2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiomicrospira_sp_kp2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123518"]),
        None,
        Some("."),
        Some("ARWI01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas stutzeri DSM10701 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1123519.PSJM300_00005";
/// let this_library_node_name2 = "1123519.PSJM300_19240";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_stutzeri_dsm10701_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_stutzeri_dsm10701_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_stutzeri_dsm10701_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_stutzeri_dsm10701_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1123519"]),
        None,
        Some("."),
        Some("PSJM300_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nafulsella turpanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1124780.ANNU01000001_gene1626";
/// let this_library_node_name2 = "1124780.ANNU01000109_gene362";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nafulsella_turpanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nafulsella_turpanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nafulsella_turpanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nafulsella_turpanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1124780"]),
        None,
        Some("."),
        Some("ANNU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema sp. JC4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1124982.MSI_00020";
/// let this_library_node_name2 = "1124982.MSI_9960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_sp_jc4_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_sp_jc4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_sp_jc4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_sp_jc4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1124982"]),
        None,
        Some("."),
        Some("MSI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas protegens CHA0 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1124983.PFLCHA0_c00010";
/// let this_library_node_name2 = "1124983.PFLCHA0_c61940";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_protegens_cha0_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_protegens_cha0_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_protegens_cha0_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_protegens_cha0_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1124983"]),
        None,
        Some("."),
        Some("PFLCHA0_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Morganella morganii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1124991.MU9_1";
/// let this_library_node_name2 = "1124991.MU9_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_morganella_morganii_node_name(this_library_node_name1));
/// assert!(is_valid_string_morganella_morganii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_morganella_morganii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_morganella_morganii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1124991"]),
        None,
        Some("."),
        Some("MU9_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema maltophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1125699.HMPREF9194_00001";
/// let this_library_node_name2 = "1125699.HMPREF9194_02339";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_maltophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_maltophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_maltophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_maltophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1125699"]),
        None,
        Some("."),
        Some("HMPREF9194_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema medium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1125700.HMPREF9195_00001";
/// let this_library_node_name2 = "1125700.HMPREF9195_02392";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_medium_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_medium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_medium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_medium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1125700"]),
        None,
        Some("."),
        Some("HMPREF9195_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema socranskii paredis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1125701.HMPREF1221_00002";
/// let this_library_node_name2 = "1125701.HMPREF1221_02481";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_socranskii_paredis_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_socranskii_paredis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_socranskii_paredis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_socranskii_paredis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1125701"]),
        None,
        Some("."),
        Some("HMPREF1221_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Olsenella profusa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1125712.HMPREF1316_0002";
/// let this_library_node_name2 = "1125712.HMPREF1316_2714";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_olsenella_profusa_node_name(this_library_node_name1));
/// assert!(is_valid_string_olsenella_profusa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_olsenella_profusa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_olsenella_profusa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1125712"]),
        None,
        Some("."),
        Some("HMPREF1316_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1125718.HMPREF1318_0001";
/// let this_library_node_name2 = "1125718.HMPREF1318_3135";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1125718"]),
        None,
        Some("."),
        Some("HMPREF1318_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema socranskii VPIDR56BR1116 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1125725.HMPREF1325_0001";
/// let this_library_node_name2 = "1125725.HMPREF1325_2681";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_socranskii_vpidr56br1116_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_socranskii_vpidr56br1116_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_socranskii_vpidr56br1116_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_socranskii_vpidr56br1116_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1125725"]),
        None,
        Some("."),
        Some("HMPREF1325_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium pyruviciproducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1125779.HMPREF1219_00004";
/// let this_library_node_name2 = "1125779.HMPREF1219_02505";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_pyruviciproducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_pyruviciproducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_pyruviciproducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_pyruviciproducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1125779"]),
        None,
        Some("."),
        Some("HMPREF1219_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deferrisoma camini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1125863.JAFN01000001_gene1";
/// let this_library_node_name2 = "1125863.JAFN01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deferrisoma_camini_node_name(this_library_node_name1));
/// assert!(is_valid_string_deferrisoma_camini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deferrisoma_camini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deferrisoma_camini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1125863"]),
        None,
        Some("."),
        Some("JAFN01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amycolatopsis orientalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1125971.ASJB01000001_gene2912";
/// let this_library_node_name2 = "1125971.ASJB01000099_gene2473";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amycolatopsis_orientalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_amycolatopsis_orientalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amycolatopsis_orientalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amycolatopsis_orientalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1125971"]),
        None,
        Some("."),
        Some("ASJB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bosea sp. 117 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1125973.JNLC01000001_gene1";
/// let this_library_node_name2 = "1125973.JNLC01000018_gene2338";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bosea_sp_117_node_name(this_library_node_name1));
/// assert!(is_valid_string_bosea_sp_117_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bosea_sp_117_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bosea_sp_117_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1125973"]),
        None,
        Some("."),
        Some("JNLC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. DOA9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1126627.BAWE01000001_gene1";
/// let this_library_node_name2 = "1126627.BAWE01000006_gene6818";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_doa9_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_doa9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_doa9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_doa9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1126627"]),
        None,
        Some("."),
        Some("BAWE0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Weissella confusa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1127131.WEISSC39_00005";
/// let this_library_node_name2 = "1127131.WEISSC39_11450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_weissella_confusa_node_name(this_library_node_name1));
/// assert!(is_valid_string_weissella_confusa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_weissella_confusa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_weissella_confusa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1127131"]),
        None,
        Some("."),
        Some("WEISSC39_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia cyriacigeorgica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1127134.NOCYR_0001";
/// let this_library_node_name2 = "1127134.NOCYR_5569";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_cyriacigeorgica_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_cyriacigeorgica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_cyriacigeorgica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_cyriacigeorgica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1127134"]),
        None,
        Some("."),
        Some("NOCYR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glaciecola lipolytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1127673.GLIP_0001";
/// let this_library_node_name2 = "1127673.GLIP_4373";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glaciecola_lipolytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_glaciecola_lipolytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glaciecola_lipolytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glaciecola_lipolytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1127673"]),
        None,
        Some("."),
        Some("GLIP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga sp. F0381 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1127692.HMPREF9075_00001";
/// let this_library_node_name2 = "1127692.HMPREF9075_02747";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_sp_f0381_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_sp_f0381_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_sp_f0381_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_sp_f0381_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1127692"]),
        None,
        Some("."),
        Some("HMPREF9075_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas sp. F0429 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1127695.HMPREF9163_00001";
/// let this_library_node_name2 = "1127695.HMPREF9163_02473";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_sp_f0429_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_sp_f0429_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_sp_f0429_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_sp_f0429_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1127695"]),
        None,
        Some("."),
        Some("HMPREF9163_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas catoniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1127696.HMPREF9134_00002";
/// let this_library_node_name2 = "1127696.HMPREF9134_01907";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_catoniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_catoniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_catoniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_catoniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1127696"]),
        None,
        Some("."),
        Some("HMPREF9134_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Veillonella atypica KON nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1128111.HMPREF0870_00001";
/// let this_library_node_name2 = "1128111.HMPREF0870_01956";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_veillonella_atypica_kon_node_name(this_library_node_name1));
/// assert!(is_valid_string_veillonella_atypica_kon_node_name(this_library_node_name2));
/// assert!(!is_valid_string_veillonella_atypica_kon_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_veillonella_atypica_kon_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1128111"]),
        None,
        Some("."),
        Some("HMPREF0870_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium acidurici nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1128398.Curi_c00010";
/// let this_library_node_name2 = "1128398.Curi_c29580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_acidurici_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_acidurici_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_acidurici_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_acidurici_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1128398"]),
        None,
        Some("."),
        Some("Curi_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacterium sp. JKG1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1128421.JAGA01000001_gene1987";
/// let this_library_node_name2 = "1128421.JAGA01000004_gene2706";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacterium_sp_jkg1_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacterium_sp_jkg1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacterium_sp_jkg1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacterium_sp_jkg1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1128421"]),
        None,
        Some("."),
        Some("JAGA0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING filamentous cyanobacterium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1128427.KB904821_gene1000";
/// let this_library_node_name2 = "1128427.KB904823_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_filamentous_cyanobacterium_node_name(this_library_node_name1));
/// assert!(is_valid_string_filamentous_cyanobacterium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_filamentous_cyanobacterium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_filamentous_cyanobacterium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1128427"]),
        None,
        Some("."),
        Some("KB90482"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glaciecola mesophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1128912.GMES_0003";
/// let this_library_node_name2 = "1128912.GMES_4621";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glaciecola_mesophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_glaciecola_mesophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glaciecola_mesophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glaciecola_mesophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1128912"]),
        None,
        Some("."),
        Some("GMES_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiroplasma melliferum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1129368.SMIPMB4A_v3c0010";
/// let this_library_node_name2 = "1129368.SMIPMB4A_v3c9850";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiroplasma_melliferum_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiroplasma_melliferum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiroplasma_melliferum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiroplasma_melliferum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1129368"]),
        None,
        Some("."),
        Some("SMIPMB4A_v3c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma hyorhinis GDL1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1129369.MYM_0001";
/// let this_library_node_name2 = "1129369.MYM_0741";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_hyorhinis_gdl1_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_hyorhinis_gdl1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_hyorhinis_gdl1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_hyorhinis_gdl1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1129369"]),
        None,
        Some("."),
        Some("MYM_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alishewanella jeotgali nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1129374.AJE_00005";
/// let this_library_node_name2 = "1129374.AJE_17790";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alishewanella_jeotgali_node_name(this_library_node_name1));
/// assert!(is_valid_string_alishewanella_jeotgali_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alishewanella_jeotgali_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alishewanella_jeotgali_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1129374"]),
        None,
        Some("."),
        Some("AJE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glaciecola psychrophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1129794.C427_0001";
/// let this_library_node_name2 = "1129794.C427_5636";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glaciecola_psychrophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_glaciecola_psychrophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glaciecola_psychrophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glaciecola_psychrophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1129794"]),
        None,
        Some("."),
        Some("C427_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thaumarchaeota sp. SCGC AB629I23 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1131266.ARWQ01000001_gene1072";
/// let this_library_node_name2 = "1131266.ARWQ01000132_gene360";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thaumarchaeota_sp_scgc_ab629i23_node_name(this_library_node_name1));
/// assert!(is_valid_string_thaumarchaeota_sp_scgc_ab629i23_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thaumarchaeota_sp_scgc_ab629i23_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thaumarchaeota_sp_scgc_ab629i23_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1131266"]),
        None,
        Some("."),
        Some("ARWQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrospina sp. AB629B18 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1131269.AQVV01000001_gene1280";
/// let this_library_node_name2 = "1131269.AQVV01000219_gene2120";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrospina_sp_ab629b18_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrospina_sp_ab629b18_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrospina_sp_ab629b18_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrospina_sp_ab629b18_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1131269"]),
        None,
        Some("."),
        Some("AQVV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas fragariae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1131451.O1K_00005";
/// let this_library_node_name2 = "1131451.O1K_20612";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_fragariae_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_fragariae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_fragariae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_fragariae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1131451"]),
        None,
        Some("."),
        Some("O1K_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dehalobacter sp. CF nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1131462.DCF50_p1";
/// let this_library_node_name2 = "1131462.DCF50_p999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dehalobacter_sp_cf_node_name(this_library_node_name1));
/// assert!(is_valid_string_dehalobacter_sp_cf_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dehalobacter_sp_cf_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dehalobacter_sp_cf_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1131462"]),
        None,
        Some("."),
        Some("DCF50_p"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosomonas cryotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1131553.JIBI01000001_gene1399";
/// let this_library_node_name2 = "1131553.JIBI01000094_gene190";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosomonas_cryotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosomonas_cryotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosomonas_cryotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosomonas_cryotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1131553"]),
        None,
        Some("."),
        Some("JIBI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus vireti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1131730.BAVI_00005";
/// let this_library_node_name2 = "1131730.BAVI_25729";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_vireti_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_vireti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_vireti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_vireti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1131730"]),
        None,
        Some("."),
        Some("BAVI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium sp. 83 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1131812.JQMS01000001_gene1";
/// let this_library_node_name2 = "1131812.JQMS01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_sp_83_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_sp_83_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_sp_83_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_sp_83_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1131812"]),
        None,
        Some("."),
        Some("JQMS01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacterium sp. 88A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1131813.AQVT01000001_gene100";
/// let this_library_node_name2 = "1131813.AQVT01000004_gene4325";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacterium_sp_88a_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacterium_sp_88a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacterium_sp_88a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacterium_sp_88a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1131813"]),
        None,
        Some("."),
        Some("AQVT0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthobacter sp. 126 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1131814.JAFO01000001_gene1";
/// let this_library_node_name2 = "1131814.JAFO01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthobacter_sp_126_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthobacter_sp_126_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthobacter_sp_126_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthobacter_sp_126_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1131814"]),
        None,
        Some("."),
        Some("JAFO01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. 35W nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1132441.KI519454_gene1";
/// let this_library_node_name2 = "1132441.KI519455_gene3955";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_35w_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_35w_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_35w_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_35w_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1132441"]),
        None,
        Some("."),
        Some("KI51945"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. 37MA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1132442.KB889752_gene1000";
/// let this_library_node_name2 = "1132442.KB889756_gene3989";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_37ma_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_37ma_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_37ma_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_37ma_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1132442"]),
        None,
        Some("."),
        Some("KB88975"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halococcus hamelinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1132509.C447_00005";
/// let this_library_node_name2 = "1132509.C447_17182";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halococcus_hamelinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_halococcus_hamelinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halococcus_hamelinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halococcus_hamelinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1132509"]),
        None,
        Some("."),
        Some("C447_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. CCGE510 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1132836.RCCGE510_00005";
/// let this_library_node_name2 = "1132836.RCCGE510_33504";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_ccge510_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_ccge510_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_ccge510_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_ccge510_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1132836"]),
        None,
        Some("."),
        Some("RCCGE510_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylotenera mobilis 13 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1132855.KB913035_gene1";
/// let this_library_node_name2 = "1132855.KB913035_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylotenera_mobilis_13_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylotenera_mobilis_13_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylotenera_mobilis_13_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylotenera_mobilis_13_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1132855"]),
        None,
        Some("."),
        Some("KB913035_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus vini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1133569.AHYZ01000001_gene748";
/// let this_library_node_name2 = "1133569.AHYZ01000218_gene1177";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_vini_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_vini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_vini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_vini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1133569"]),
        None,
        Some("."),
        Some("AHYZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia brasiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1133849.O3I_000005";
/// let this_library_node_name2 = "1133849.O3I_042160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_brasiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_brasiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_brasiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_brasiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1133849"]),
        None,
        Some("."),
        Some("O3I_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces hygroscopicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1133850.SHJG_0001";
/// let this_library_node_name2 = "1133850.SHJG_p1184";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_hygroscopicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_hygroscopicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_hygroscopicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_hygroscopicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1133850"]),
        None,
        Some("."),
        Some("SHJG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. L1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1134413.ANNK01000001_gene2112";
/// let this_library_node_name2 = "1134413.ANNK01000196_gene2970";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_l1_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_l1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_l1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_l1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1134413"]),
        None,
        Some("."),
        Some("ANNK01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces somaliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1134445.AJJM01000001_gene2655";
/// let this_library_node_name2 = "1134445.AJJM01000243_gene973";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_somaliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_somaliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_somaliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_somaliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1134445"]),
        None,
        Some("."),
        Some("AJJM01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellvibrio sp. BR nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1134474.O59_000001";
/// let this_library_node_name2 = "1134474.O59_005001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellvibrio_sp_br_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellvibrio_sp_br_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellvibrio_sp_br_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellvibrio_sp_br_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1134474"]),
        None,
        Some("."),
        Some("O59_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella koehlerae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1134510.O9A_00001";
/// let this_library_node_name2 = "1134510.O9A_01464";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_koehlerae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_koehlerae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_koehlerae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_koehlerae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1134510"]),
        None,
        Some("."),
        Some("O9A_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylocystis parvus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1134912.AJTV01000001_gene1279";
/// let this_library_node_name2 = "1134912.AJTV01000105_gene2000";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylocystis_parvus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylocystis_parvus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylocystis_parvus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylocystis_parvus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1134912"]),
        None,
        Some("."),
        Some("AJTV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas fragi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1136138.JH604622_gene1000";
/// let this_library_node_name2 = "1136138.JH604631_gene196";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_fragi_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_fragi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_fragi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_fragi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1136138"]),
        None,
        Some("."),
        Some("JH6046"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio cyclitrophicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1136163.M565_ctg1P0001";
/// let this_library_node_name2 = "1136163.M565_ctg5P1514";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_cyclitrophicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_cyclitrophicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_cyclitrophicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_cyclitrophicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1136163"]),
        None,
        Some("."),
        Some("M565_ctg"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus pentosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1136177.KCA1_0001";
/// let this_library_node_name2 = "1136177.KCA1_3019";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_pentosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_pentosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_pentosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_pentosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1136177"]),
        None,
        Some("."),
        Some("KCA1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinispora pacifica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1136417.AZWE01000001_gene3676";
/// let this_library_node_name2 = "1136417.AZWE01000138_gene3295";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinispora_pacifica_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinispora_pacifica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinispora_pacifica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinispora_pacifica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1136417"]),
        None,
        Some("."),
        Some("AZWE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardiopsis sp. CNT312 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1137268.AZXF01000001_gene157";
/// let this_library_node_name2 = "1137268.AZXF01000067_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardiopsis_sp_cnt312_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardiopsis_sp_cnt312_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardiopsis_sp_cnt312_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardiopsis_sp_cnt312_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1137268"]),
        None,
        Some("."),
        Some("AZXF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. CNH099 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1137269.AZWL01000001_gene5236";
/// let this_library_node_name2 = "1137269.AZWL01000104_gene188";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_cnh099_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_cnh099_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_cnh099_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_cnh099_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1137269"]),
        None,
        Some("."),
        Some("AZWL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharomonospora sp. CNQ490 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1137271.AZUM01000001_gene1000";
/// let this_library_node_name2 = "1137271.AZUM01000025_gene327";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharomonospora_sp_cnq490_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharomonospora_sp_cnq490_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharomonospora_sp_cnq490_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharomonospora_sp_cnq490_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1137271"]),
        None,
        Some("."),
        Some("AZUM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Formosa sp. AK20 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1137281.D778_00001";
/// let this_library_node_name2 = "1137281.D778_02844";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_formosa_sp_ak20_node_name(this_library_node_name1));
/// assert!(is_valid_string_formosa_sp_ak20_node_name(this_library_node_name2));
/// assert!(!is_valid_string_formosa_sp_ak20_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_formosa_sp_ak20_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1137281"]),
        None,
        Some("."),
        Some("D778_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Endozoicomonas numazuensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1137799.GZ78_00005";
/// let this_library_node_name2 = "1137799.GZ78_29320";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_endozoicomonas_numazuensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_endozoicomonas_numazuensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_endozoicomonas_numazuensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_endozoicomonas_numazuensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1137799"]),
        None,
        Some("."),
        Some("GZ78_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus curieae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1138822.PL11_00005";
/// let this_library_node_name2 = "1138822.PL11_10715";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_curieae_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_curieae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_curieae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_curieae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1138822"]),
        None,
        Some("."),
        Some("PL11_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus dispar nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1139219.I569_00001";
/// let this_library_node_name2 = "1139219.I569_02720";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_dispar_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_dispar_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_dispar_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_dispar_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1139219"]),
        None,
        Some("."),
        Some("I569_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus saccharolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1139996.OMQ_00011";
/// let this_library_node_name2 = "1139996.OMQ_02642";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_saccharolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_saccharolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_saccharolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_saccharolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1139996"]),
        None,
        Some("."),
        Some("OMQ_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus durans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1140001.I571_00001";
/// let this_library_node_name2 = "1140001.I571_03098";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_durans_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_durans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_durans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_durans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1140001"]),
        None,
        Some("."),
        Some("I571_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus avium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1140002.I570_00001";
/// let this_library_node_name2 = "1140002.I570_04565";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_avium_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_avium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_avium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_avium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1140002"]),
        None,
        Some("."),
        Some("I570_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus sulfureus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1140003.I573_00002";
/// let this_library_node_name2 = "1140003.I573_02259";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_sulfureus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_sulfureus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_sulfureus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_sulfureus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1140003"]),
        None,
        Some("."),
        Some("I573_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus intermedius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1141106.CAIB01000001_gene1";
/// let this_library_node_name2 = "1141106.CAIB01000286_gene2655";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_intermedius_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_intermedius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_intermedius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_intermedius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1141106"]),
        None,
        Some("."),
        Some("CAIB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Providencia burhodogranariea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1141662.OOA_00005";
/// let this_library_node_name2 = "1141662.OOA_19806";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_providencia_burhodogranariea_node_name(this_library_node_name1));
/// assert!(is_valid_string_providencia_burhodogranariea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_providencia_burhodogranariea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_providencia_burhodogranariea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1141662"]),
        None,
        Some("."),
        Some("OOA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Providencia rettgeri Dmel1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1141663.OOC_00005";
/// let this_library_node_name2 = "1141663.OOC_20129";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_providencia_rettgeri_dmel1_node_name(this_library_node_name1));
/// assert!(is_valid_string_providencia_rettgeri_dmel1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_providencia_rettgeri_dmel1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_providencia_rettgeri_dmel1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1141663"]),
        None,
        Some("."),
        Some("OOC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phycisphaera mikurensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1142394.PSMK_00010";
/// let this_library_node_name2 = "1142394.PSMK_p00810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phycisphaera_mikurensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_phycisphaera_mikurensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phycisphaera_mikurensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phycisphaera_mikurensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1142394"]),
        None,
        Some("."),
        Some("PSMK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wigglesworthia glossinidia sp. Gmo nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1142511.WIGMOR_0001";
/// let this_library_node_name2 = "1142511.WIGMOR_0678";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wigglesworthia_glossinidia_sp_gmo_node_name(this_library_node_name1));
/// assert!(is_valid_string_wigglesworthia_glossinidia_sp_gmo_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wigglesworthia_glossinidia_sp_gmo_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wigglesworthia_glossinidia_sp_gmo_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1142511"]),
        None,
        Some("."),
        Some("WIGMOR_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydia gallinacea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1143323.M787_0001";
/// let this_library_node_name2 = "1143323.M787_0951";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydia_gallinacea_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydia_gallinacea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydia_gallinacea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydia_gallinacea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1143323"]),
        None,
        Some("."),
        Some("M787_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corallococcus coralloides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144275.COCOR_00001";
/// let this_library_node_name2 = "1144275.COCOR_08101";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corallococcus_coralloides_node_name(this_library_node_name1));
/// assert!(is_valid_string_corallococcus_coralloides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corallococcus_coralloides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corallococcus_coralloides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144275"]),
        None,
        Some("."),
        Some("COCOR_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novosphingobium sp. AP12 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144305.PMI02_00001";
/// let this_library_node_name2 = "1144305.PMI02_05595";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novosphingobium_sp_ap12_node_name(this_library_node_name1));
/// assert!(is_valid_string_novosphingobium_sp_ap12_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novosphingobium_sp_ap12_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novosphingobium_sp_ap12_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144305"]),
        None,
        Some("."),
        Some("PMI02_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium sp. AP49 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144307.PMI04_00024";
/// let this_library_node_name2 = "1144307.PMI04_04613";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_sp_ap49_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_sp_ap49_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_sp_ap49_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_sp_ap49_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144307"]),
        None,
        Some("."),
        Some("PMI04_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. CF080 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144310.PMI07_000001";
/// let this_library_node_name2 = "1144310.PMI07_006684";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_cf080_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_cf080_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_cf080_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_cf080_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144310"]),
        None,
        Some("."),
        Some("PMI07_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. CF122 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144312.PMI09_00001";
/// let this_library_node_name2 = "1144312.PMI09_06158";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_cf122_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_cf122_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_cf122_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_cf122_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144312"]),
        None,
        Some("."),
        Some("PMI09_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium sp. CF136 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144313.PMI10_00001";
/// let this_library_node_name2 = "1144313.PMI10_04417";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_sp_cf136_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_sp_cf136_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_sp_cf136_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_sp_cf136_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144313"]),
        None,
        Some("."),
        Some("PMI10_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Herbaspirillum sp. CF444 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144319.PMI16_00001";
/// let this_library_node_name2 = "1144319.PMI16_05070";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_herbaspirillum_sp_cf444_node_name(this_library_node_name1));
/// assert!(is_valid_string_herbaspirillum_sp_cf444_node_name(this_library_node_name2));
/// assert!(!is_valid_string_herbaspirillum_sp_cf444_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_herbaspirillum_sp_cf444_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144319"]),
        None,
        Some("."),
        Some("PMI16_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. GM21 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144325.PMI22_00001";
/// let this_library_node_name2 = "1144325.PMI22_06161";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_gm21_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_gm21_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_gm21_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_gm21_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144325"]),
        None,
        Some("."),
        Some("PMI22_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Herbaspirillum sp. YR522 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144342.PMI40_00001";
/// let this_library_node_name2 = "1144342.PMI40_05030";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_herbaspirillum_sp_yr522_node_name(this_library_node_name1));
/// assert!(is_valid_string_herbaspirillum_sp_yr522_node_name(this_library_node_name2));
/// assert!(!is_valid_string_herbaspirillum_sp_yr522_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_herbaspirillum_sp_yr522_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144342"]),
        None,
        Some("."),
        Some("PMI40_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phyllobacterium sp. YR531 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144343.PMI41_00004";
/// let this_library_node_name2 = "1144343.PMI41_04984";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phyllobacterium_sp_yr531_node_name(this_library_node_name1));
/// assert!(is_valid_string_phyllobacterium_sp_yr531_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phyllobacterium_sp_yr531_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phyllobacterium_sp_yr531_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144343"]),
        None,
        Some("."),
        Some("PMI41_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. CIP102129 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144664.F973_00004";
/// let this_library_node_name2 = "1144664.F973_02882";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_cip102129_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_cip102129_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_cip102129_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_cip102129_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144664"]),
        None,
        Some("."),
        Some("F973_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. CIP56.2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144672.F966_00001";
/// let this_library_node_name2 = "1144672.F966_04142";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_cip562_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_cip562_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_cip562_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_cip562_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144672"]),
        None,
        Some("."),
        Some("F966_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsia helvetica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144888.CM001467_gene1";
/// let this_library_node_name2 = "1144888.CM001468_gene1663";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsia_helvetica_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsia_helvetica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsia_helvetica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsia_helvetica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144888"]),
        None,
        Some("."),
        Some("CM00146"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibacter ubique HIMB058 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1144932.ATTF01000001_gene153";
/// let this_library_node_name2 = "1144932.ATTF01000059_gene1107";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibacter_ubique_himb058_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibacter_ubique_himb058_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibacter_ubique_himb058_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibacter_ubique_himb058_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1144932"]),
        None,
        Some("."),
        Some("ATTF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysinibacillus varians nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1145276.T479_00005";
/// let this_library_node_name2 = "1145276.T479_23720";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysinibacillus_varians_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysinibacillus_varians_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysinibacillus_varians_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysinibacillus_varians_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1145276"]),
        None,
        Some("."),
        Some("T479_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blastococcus saxobsidens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1146883.BLASA_0001";
/// let this_library_node_name2 = "1146883.BLASA_5078";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blastococcus_saxobsidens_node_name(this_library_node_name1));
/// assert!(is_valid_string_blastococcus_saxobsidens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blastococcus_saxobsidens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blastococcus_saxobsidens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1146883"]),
        None,
        Some("."),
        Some("BLASA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium asteroides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1147128.BAST_0001";
/// let this_library_node_name2 = "1147128.BAST_1702";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_asteroides_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_asteroides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_asteroides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_asteroides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1147128"]),
        None,
        Some("."),
        Some("BAST_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas pseudoalcaligenes KF707 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1149133.ppKF707_0001";
/// let this_library_node_name2 = "1149133.ppKF707_6209";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_pseudoalcaligenes_kf707_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_pseudoalcaligenes_kf707_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_pseudoalcaligenes_kf707_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_pseudoalcaligenes_kf707_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1149133"]),
        None,
        Some("."),
        Some("ppKF707_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. 9MFCol31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1150398.JIBJ01000001_gene1353";
/// let this_library_node_name2 = "1150398.JIBJ01000032_gene2169";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_9mfcol31_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_9mfcol31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_9mfcol31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_9mfcol31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1150398"]),
        None,
        Some("."),
        Some("JIBJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leifsonia sp. 109 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1150399.AQYK01000001_gene10";
/// let this_library_node_name2 = "1150399.AQYK01000005_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leifsonia_sp_109_node_name(this_library_node_name1));
/// assert!(is_valid_string_leifsonia_sp_109_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leifsonia_sp_109_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leifsonia_sp_109_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1150399"]),
        None,
        Some("."),
        Some("AQYK0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodospirillum photometricum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1150469.378401835";
/// let this_library_node_name2 = "1150469.RSPPHO_03287";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodospirillum_photometricum_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodospirillum_photometricum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodospirillum_photometricum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodospirillum_photometricum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1150469"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesoaciditoga lauensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1150474.JQJI01000001_gene1746";
/// let this_library_node_name2 = "1150474.JQJI01000067_gene116";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesoaciditoga_lauensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesoaciditoga_lauensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesoaciditoga_lauensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesoaciditoga_lauensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1150474"]),
        None,
        Some("."),
        Some("JQJI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium phlei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1150599.MPHLEI_00005";
/// let this_library_node_name2 = "1150599.MPHLEI_27413";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_phlei_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_phlei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_phlei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_phlei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1150599"]),
        None,
        Some("."),
        Some("MPHLEI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arcticibacter svalbardensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1150600.ADIARSV_0001";
/// let this_library_node_name2 = "1150600.ADIARSV_4350";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arcticibacter_svalbardensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_arcticibacter_svalbardensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arcticibacter_svalbardensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arcticibacter_svalbardensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1150600"]),
        None,
        Some("."),
        Some("ADIARSV_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurospirillum multivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1150621.SMUL_0001";
/// let this_library_node_name2 = "1150621.SMUL_3301";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurospirillum_multivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurospirillum_multivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurospirillum_multivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurospirillum_multivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1150621"]),
        None,
        Some("."),
        Some("SMUL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phaeospirillum molischianum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1150626.PHAMO_100001";
/// let this_library_node_name2 = "1150626.PHAMO_90001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phaeospirillum_molischianum_node_name(this_library_node_name1));
/// assert!(is_valid_string_phaeospirillum_molischianum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phaeospirillum_molischianum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phaeospirillum_molischianum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1150626"]),
        None,
        Some("."),
        Some("PHAMO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Micromonospora lupini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1150864.MILUP08_30001";
/// let this_library_node_name2 = "1150864.MILUP08_46863";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_micromonospora_lupini_node_name(this_library_node_name1));
/// assert!(is_valid_string_micromonospora_lupini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_micromonospora_lupini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_micromonospora_lupini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1150864"]),
        None,
        Some("."),
        Some("MILUP08_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tsukamurella sp. 1534 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1151061.CAJY01000001_gene2953";
/// let this_library_node_name2 = "1151061.CAJY01000042_gene3715";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tsukamurella_sp_1534_node_name(this_library_node_name1));
/// assert!(is_valid_string_tsukamurella_sp_1534_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tsukamurella_sp_1534_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tsukamurella_sp_1534_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1151061"]),
        None,
        Some("."),
        Some("CAJY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rahnella aquatilis HX2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1151116.Q7S_00005";
/// let this_library_node_name2 = "1151116.Q7S_22550";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rahnella_aquatilis_hx2_node_name(this_library_node_name1));
/// assert!(is_valid_string_rahnella_aquatilis_hx2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rahnella_aquatilis_hx2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rahnella_aquatilis_hx2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1151116"]),
        None,
        Some("."),
        Some("Q7S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermococcus zilligii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1151117.AJLF01000001_gene1000";
/// let this_library_node_name2 = "1151117.AJLF01000005_gene1795";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermococcus_zilligii_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermococcus_zilligii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermococcus_zilligii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermococcus_zilligii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1151117"]),
        None,
        Some("."),
        Some("AJLF0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. 161MFSha21 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1151118.KB895783_gene3313";
/// let this_library_node_name2 = "1151118.KB895824_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_161mfsha21_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_161mfsha21_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_161mfsha21_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_161mfsha21_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1151118"]),
        None,
        Some("."),
        Some("KB895"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. 162MFSha11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1151119.KB895488_gene1000";
/// let this_library_node_name2 = "1151119.KB895540_gene2458";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_162mfsha11_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_162mfsha11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_162mfsha11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_162mfsha11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1151119"]),
        None,
        Some("."),
        Some("KB895"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium sp. 292MF nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1151122.AQYD01000003_gene2578";
/// let this_library_node_name2 = "1151122.AQYD01000007_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_sp_292mf_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_sp_292mf_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_sp_292mf_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_sp_292mf_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1151122"]),
        None,
        Some("."),
        Some("AQYD0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium paraoxydans 77MFTsu32 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1151126.AQYI01000002_gene1";
/// let this_library_node_name2 = "1151126.AQYI01000007_gene2269";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_paraoxydans_77mftsu32_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_paraoxydans_77mftsu32_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_paraoxydans_77mftsu32_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_paraoxydans_77mftsu32_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1151126"]),
        None,
        Some("."),
        Some("AQYI0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas mandelii 36MFCvi11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1151127.KB906325_gene4418";
/// let this_library_node_name2 = "1151127.KB906353_gene878";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_mandelii_36mfcvi11_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_mandelii_36mfcvi11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_mandelii_36mfcvi11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_mandelii_36mfcvi11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1151127"]),
        None,
        Some("."),
        Some("KB9063"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoclostridium difficile CD160 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1151292.QEW_0003";
/// let this_library_node_name2 = "1151292.QEW_4724";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoclostridium_difficile_cd160_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoclostridium_difficile_cd160_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoclostridium_difficile_cd160_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoclostridium_difficile_cd160_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1151292"]),
        None,
        Some("."),
        Some("QEW_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leuconostoc pseudomesenteroides nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1154757.Q5C_00010";
/// let this_library_node_name2 = "1154757.Q5C_10760";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leuconostoc_pseudomesenteroides_node_name(this_library_node_name1));
/// assert!(is_valid_string_leuconostoc_pseudomesenteroides_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leuconostoc_pseudomesenteroides_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leuconostoc_pseudomesenteroides_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1154757"]),
        None,
        Some("."),
        Some("Q5C_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus agalactiae LMG14747 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1154860.SAG0136_00005";
/// let this_library_node_name2 = "1154860.SAG0136_11845";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_agalactiae_lmg14747_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_agalactiae_lmg14747_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_agalactiae_lmg14747_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_agalactiae_lmg14747_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1154860"]),
        None,
        Some("."),
        Some("SAG0136_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. LaPpAH108 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1155714.KB891987_gene2231";
/// let this_library_node_name2 = "1155714.KB892000_gene433";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_lappah108_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_lappah108_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_lappah108_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_lappah108_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1155714"]),
        None,
        Some("."),
        Some("KB89"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. MspMPM5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1155718.KB891853_gene3230";
/// let this_library_node_name2 = "1155718.KB891972_gene7297";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_mspmpm5_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_mspmpm5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_mspmpm5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_mspmpm5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1155718"]),
        None,
        Some("."),
        Some("KB891"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. HmicA12 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1156844.KB891797_gene5304";
/// let this_library_node_name2 = "1156844.KB891852_gene3935";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_hmica12_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_hmica12_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_hmica12_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_hmica12_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1156844"]),
        None,
        Some("."),
        Some("KB891"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Achromobacter piechaudii HLE nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1156919.QWC_00005";
/// let this_library_node_name2 = "1156919.QWC_32047";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_achromobacter_piechaudii_hle_node_name(this_library_node_name1));
/// assert!(is_valid_string_achromobacter_piechaudii_hle_node_name(this_library_node_name2));
/// assert!(!is_valid_string_achromobacter_piechaudii_hle_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_achromobacter_piechaudii_hle_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1156919"]),
        None,
        Some("."),
        Some("QWC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agrobacterium albertimagni nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1156935.QWE_00005";
/// let this_library_node_name2 = "1156935.QWE_24285";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agrobacterium_albertimagni_node_name(this_library_node_name1));
/// assert!(is_valid_string_agrobacterium_albertimagni_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agrobacterium_albertimagni_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agrobacterium_albertimagni_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1156935"]),
        None,
        Some("."),
        Some("QWE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylacidiphilum fumariolicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1156937.MFUM_1000002";
/// let this_library_node_name2 = "1156937.MFUM_990026";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylacidiphilum_fumariolicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylacidiphilum_fumariolicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylacidiphilum_fumariolicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylacidiphilum_fumariolicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1156937"]),
        None,
        Some("."),
        Some("MFUM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tumebacillus flagellatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1157490.EL26_00005";
/// let this_library_node_name2 = "1157490.EL26_24490";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tumebacillus_flagellatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_tumebacillus_flagellatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tumebacillus_flagellatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tumebacillus_flagellatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1157490"]),
        None,
        Some("."),
        Some("EL26_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. LaPpAH95 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1157632.AQWQ01000001_gene5281";
/// let this_library_node_name2 = "1157632.AQWQ01000032_gene420";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_lappah95_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_lappah95_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_lappah95_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_lappah95_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1157632"]),
        None,
        Some("."),
        Some("AQWQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. Amel2xE9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1157634.KB912943_gene3999";
/// let this_library_node_name2 = "1157634.KB913012_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_amel2xe9_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_amel2xe9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_amel2xe9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_amel2xe9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1157634"]),
        None,
        Some("."),
        Some("KB91"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. ATexABD23 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1157635.KB892001_gene2539";
/// let this_library_node_name2 = "1157635.KB892089_gene4970";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_atexabd23_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_atexabd23_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_atexabd23_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_atexabd23_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1157635"]),
        None,
        Some("."),
        Some("KB8920"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. BoleA5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1157637.KB892090_gene5904";
/// let this_library_node_name2 = "1157637.KB892156_gene4154";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_bolea5_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_bolea5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_bolea5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_bolea5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1157637"]),
        None,
        Some("."),
        Some("KB892"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. PsTaAH124 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1157638.KB892157_gene1261";
/// let this_library_node_name2 = "1157638.KB892209_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_pstaah124_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_pstaah124_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_pstaah124_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_pstaah124_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1157638"]),
        None,
        Some("."),
        Some("KB892"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. FxanaC1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1157640.AQWO01000001_gene6093";
/// let this_library_node_name2 = "1157640.AQWO01000063_gene2286";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_fxanac1_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_fxanac1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_fxanac1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_fxanac1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1157640"]),
        None,
        Some("."),
        Some("AQWO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Variovorax paradoxus 110B nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1157708.KB907450_gene5100";
/// let this_library_node_name2 = "1157708.KB907495_gene4506";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_variovorax_paradoxus_110b_node_name(this_library_node_name1));
/// assert!(is_valid_string_variovorax_paradoxus_110b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_variovorax_paradoxus_110b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_variovorax_paradoxus_110b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1157708"]),
        None,
        Some("."),
        Some("KB9074"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium sp. 155 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1157943.KB892705_gene1";
/// let this_library_node_name2 = "1157943.KB892706_gene4247";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_sp_155_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_sp_155_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_sp_155_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_sp_155_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1157943"]),
        None,
        Some("."),
        Some("KB89270"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. 135MFCol51 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158050.KB895452_gene1";
/// let this_library_node_name2 = "1158050.KB895487_gene3938";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_135mfcol51_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_135mfcol51_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_135mfcol51_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_135mfcol51_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158050"]),
        None,
        Some("."),
        Some("KB8954"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALJT nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158146.KB907121_gene1000";
/// let this_library_node_name2 = "1158146.KB907140_gene532";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_aljt_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_aljt_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_aljt_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_aljt_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158146"]),
        None,
        Some("."),
        Some("KB9071"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALD1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158150.KB906241_gene1000";
/// let this_library_node_name2 = "1158150.KB906252_gene19";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_ald1_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_ald1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_ald1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_ald1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158150"]),
        None,
        Some("."),
        Some("KB9062"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALMg11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158165.KB898871_gene2019";
/// let this_library_node_name2 = "1158165.KB898888_gene2561";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_almg11_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_almg11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_almg11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_almg11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158165"]),
        None,
        Some("."),
        Some("KB8988"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALE31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158182.KB905020_gene1658";
/// let this_library_node_name2 = "1158182.KB905035_gene2467";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_ale31_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_ale31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_ale31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_ale31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158182"]),
        None,
        Some("."),
        Some("KB9050"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiomonas sp. FBCd nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158292.JPOE01000001_gene3951";
/// let this_library_node_name2 = "1158292.JPOE01000006_gene3950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiomonas_sp_fbcd_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiomonas_sp_fbcd_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiomonas_sp_fbcd_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiomonas_sp_fbcd_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158292"]),
        None,
        Some("."),
        Some("JPOE0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. 10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158294.JOMI01000001_gene1334";
/// let this_library_node_name2 = "1158294.JOMI01000009_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_10_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158294"]),
        None,
        Some("."),
        Some("JOMI0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfurobacterium sp. TC51 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158318.ATXC01000001_gene1";
/// let this_library_node_name2 = "1158318.ATXC01000004_gene1688";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfurobacterium_sp_tc51_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfurobacterium_sp_tc51_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfurobacterium_sp_tc51_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfurobacterium_sp_tc51_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158318"]),
        None,
        Some("."),
        Some("ATXC0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Persephonella sp. IF05L8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158338.JNLJ01000001_gene100";
/// let this_library_node_name2 = "1158338.JNLJ01000005_gene1903";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_persephonella_sp_if05l8_node_name(this_library_node_name1));
/// assert!(is_valid_string_persephonella_sp_if05l8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_persephonella_sp_if05l8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_persephonella_sp_if05l8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158338"]),
        None,
        Some("."),
        Some("JNLJ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Persephonella sp. KM09Lau8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158345.JNLL01000001_gene1";
/// let this_library_node_name2 = "1158345.JNLL01000002_gene2248";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_persephonella_sp_km09lau8_node_name(this_library_node_name1));
/// assert!(is_valid_string_persephonella_sp_km09lau8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_persephonella_sp_km09lau8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_persephonella_sp_km09lau8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158345"]),
        None,
        Some("."),
        Some("JNLL0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus malodoratus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158601.I585_00015";
/// let this_library_node_name2 = "1158601.I585_04581";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_malodoratus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_malodoratus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_malodoratus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_malodoratus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158601"]),
        None,
        Some("."),
        Some("I585_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus raffinosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158602.I590_00001";
/// let this_library_node_name2 = "1158602.I590_04311";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_raffinosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_raffinosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_raffinosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_raffinosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158602"]),
        None,
        Some("."),
        Some("I590_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus villorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158604.I591_00003";
/// let this_library_node_name2 = "1158604.I591_02899";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_villorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_villorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_villorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_villorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158604"]),
        None,
        Some("."),
        Some("I591_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus asini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158606.I579_00001";
/// let this_library_node_name2 = "1158606.I579_02511";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_asini_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_asini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_asini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_asini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158606"]),
        None,
        Some("."),
        Some("I579_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus pallens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158607.UAU_00001";
/// let this_library_node_name2 = "1158607.UAU_05317";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_pallens_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_pallens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_pallens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_pallens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158607"]),
        None,
        Some("."),
        Some("UAU_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus haemoperoxidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158608.I583_00028";
/// let this_library_node_name2 = "1158608.I583_03276";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_haemoperoxidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_haemoperoxidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_haemoperoxidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_haemoperoxidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158608"]),
        None,
        Some("."),
        Some("I583_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus moraviensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158609.I586_00014";
/// let this_library_node_name2 = "1158609.I586_03403";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_moraviensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_moraviensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_moraviensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_moraviensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158609"]),
        None,
        Some("."),
        Some("I586_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus phoeniculicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158610.UC3_00011";
/// let this_library_node_name2 = "1158610.UC3_03587";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_phoeniculicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_phoeniculicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_phoeniculicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_phoeniculicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158610"]),
        None,
        Some("."),
        Some("UC3_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus caccae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158612.I580_00002";
/// let this_library_node_name2 = "1158612.I580_03303";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_caccae_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_caccae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_caccae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_caccae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158612"]),
        None,
        Some("."),
        Some("I580_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus gilvus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158614.I592_00001";
/// let this_library_node_name2 = "1158614.I592_04206";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_gilvus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_gilvus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_gilvus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_gilvus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158614"]),
        None,
        Some("."),
        Some("I592_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALJ7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158756.AQXQ01000001_gene2294";
/// let this_library_node_name2 = "1158756.AQXQ01000012_gene2049";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_alj7_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_alj7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_alj7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_alj7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158756"]),
        None,
        Some("."),
        Some("AQXQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALJ11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158760.AQXP01000001_gene225";
/// let this_library_node_name2 = "1158760.AQXP01000055_gene1377";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_alj11_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_alj11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_alj11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_alj11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158760"]),
        None,
        Some("."),
        Some("AQXP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALJ16 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1158762.KB898037_gene2126";
/// let this_library_node_name2 = "1158762.KB898068_gene1173";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_alj16_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_alj16_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_alj16_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_alj16_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1158762"]),
        None,
        Some("."),
        Some("KB8980"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus equorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1159488.SEQMU2_00005";
/// let this_library_node_name2 = "1159488.SEQMU2_14950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_equorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_equorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_equorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_equorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1159488"]),
        None,
        Some("."),
        Some("SEQMU2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bordetella sp. FB8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1159870.KB907784_gene10";
/// let this_library_node_name2 = "1159870.KB907785_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bordetella_sp_fb8_node_name(this_library_node_name1));
/// assert!(is_valid_string_bordetella_sp_fb8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bordetella_sp_fb8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bordetella_sp_fb8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1159870"]),
        None,
        Some("."),
        Some("KB90778"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia sp. BMG111209 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1160137.KB907307_gene1";
/// let this_library_node_name2 = "1160137.KB907311_gene4466";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_sp_bmg111209_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_sp_bmg111209_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_sp_bmg111209_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_sp_bmg111209_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1160137"]),
        None,
        Some("."),
        Some("KB9073"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ureibacillus thermosphaericus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1160707.AJIK01000001_gene164";
/// let this_library_node_name2 = "1160707.AJIK01000063_gene2704";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ureibacillus_thermosphaericus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ureibacillus_thermosphaericus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ureibacillus_thermosphaericus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ureibacillus_thermosphaericus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1160707"]),
        None,
        Some("."),
        Some("AJIK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces auratus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1160718.SU9_00005";
/// let this_library_node_name2 = "1160718.SU9_33948";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_auratus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_auratus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_auratus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_auratus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1160718"]),
        None,
        Some("."),
        Some("SU9_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus bicirculans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1160721.RBI_I00001";
/// let this_library_node_name2 = "1160721.RBI_II00659";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_bicirculans_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_bicirculans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_bicirculans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_bicirculans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1160721"]),
        None,
        Some("."),
        Some("RBI_I"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Maricaulis sp. JL2009 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1161401.ASJA01000001_gene232";
/// let this_library_node_name2 = "1161401.ASJA01000039_gene909";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_maricaulis_sp_jl2009_node_name(this_library_node_name1));
/// assert!(is_valid_string_maricaulis_sp_jl2009_node_name(this_library_node_name2));
/// assert!(!is_valid_string_maricaulis_sp_jl2009_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_maricaulis_sp_jl2009_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1161401"]),
        None,
        Some("."),
        Some("ASJA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. ACC21 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1161413.HMPREF1510_0001";
/// let this_library_node_name2 = "1161413.HMPREF1510_2045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_acc21_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_acc21_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_acc21_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_acc21_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1161413"]),
        None,
        Some("."),
        Some("HMPREF1510_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium nodatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1161902.HMPREF0378_0001";
/// let this_library_node_name2 = "1161902.HMPREF0378_1753";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_nodatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_nodatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_nodatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_nodatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1161902"]),
        None,
        Some("."),
        Some("HMPREF0378_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptospirillum ferrooxidans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1162668.LFE_0001";
/// let this_library_node_name2 = "1162668.LFE_2481";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptospirillum_ferrooxidans_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptospirillum_ferrooxidans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptospirillum_ferrooxidans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptospirillum_ferrooxidans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1162668"]),
        None,
        Some("."),
        Some("LFE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phytoplasma peanut witchesbroom nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1163385.PNWB_v1c0080";
/// let this_library_node_name2 = "1163385.PNWB_v1c4860";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phytoplasma_peanut_witchesbroom_node_name(this_library_node_name1));
/// assert!(is_valid_string_phytoplasma_peanut_witchesbroom_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phytoplasma_peanut_witchesbroom_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phytoplasma_peanut_witchesbroom_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1163385"]),
        None,
        Some("."),
        Some("PNWB_v1c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Francisella noatunensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1163389.OOM_0001";
/// let this_library_node_name2 = "1163389.OOM_1836";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_francisella_noatunensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_francisella_noatunensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_francisella_noatunensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_francisella_noatunensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1163389"]),
        None,
        Some("."),
        Some("OOM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. HYS nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1163398.AJJP01000001_gene3314";
/// let this_library_node_name2 = "1163398.AJJP01000229_gene2406";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_hys_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_hys_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_hys_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_hys_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1163398"]),
        None,
        Some("."),
        Some("AJJP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodanobacter spathiphylli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1163407.UU7_00005";
/// let this_library_node_name2 = "1163407.UU7_17328";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodanobacter_spathiphylli_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodanobacter_spathiphylli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodanobacter_spathiphylli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodanobacter_spathiphylli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1163407"]),
        None,
        Some("."),
        Some("UU7_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodanobacter fulvus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1163408.UU9_00005";
/// let this_library_node_name2 = "1163408.UU9_17118";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodanobacter_fulvus_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodanobacter_fulvus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodanobacter_fulvus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodanobacter_fulvus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1163408"]),
        None,
        Some("."),
        Some("UU9_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodanobacter thiooxydans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1163409.UUA_00005";
/// let this_library_node_name2 = "1163409.UUA_18629";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodanobacter_thiooxydans_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodanobacter_thiooxydans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodanobacter_thiooxydans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodanobacter_thiooxydans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1163409"]),
        None,
        Some("."),
        Some("UUA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfuricella denitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1163617.SCD_n00001";
/// let this_library_node_name2 = "1163617.SCD_n03033";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfuricella_denitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfuricella_denitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfuricella_denitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfuricella_denitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1163617"]),
        None,
        Some("."),
        Some("SCD_n0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. 12 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1163671.JAGI01000001_gene1";
/// let this_library_node_name2 = "1163671.JAGI01000003_gene935";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_12_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_12_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_12_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_12_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1163671"]),
        None,
        Some("."),
        Some("JAGI0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fervidicoccus fontis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1163730.FFONT_0001";
/// let this_library_node_name2 = "1163730.FFONT_1394";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fervidicoccus_fontis_node_name(this_library_node_name1));
/// assert!(is_valid_string_fervidicoccus_fontis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fervidicoccus_fontis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fervidicoccus_fontis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1163730"]),
        None,
        Some("."),
        Some("FFONT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter cetorum MIT995656 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1163745.HCD_00005";
/// let this_library_node_name2 = "1163745.HCD_08640";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_cetorum_mit995656_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_cetorum_mit995656_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_cetorum_mit995656_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_cetorum_mit995656_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1163745"]),
        None,
        Some("."),
        Some("HCD_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Richelia intracellularis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1165094.RINTHH_100";
/// let this_library_node_name2 = "1165094.RINTHH_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_richelia_intracellularis_node_name(this_library_node_name1));
/// assert!(is_valid_string_richelia_intracellularis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_richelia_intracellularis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_richelia_intracellularis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1165094"]),
        None,
        Some("."),
        Some("RINTHH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylotenera sp. 73s nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1165096.ARWF01000001_gene1";
/// let this_library_node_name2 = "1165096.ARWF01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylotenera_sp_73s_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylotenera_sp_73s_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylotenera_sp_73s_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylotenera_sp_73s_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1165096"]),
        None,
        Some("."),
        Some("ARWF01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurovum sp. AR nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1165841.SULAR_00005";
/// let this_library_node_name2 = "1165841.SULAR_10714";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurovum_sp_ar_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurovum_sp_ar_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurovum_sp_ar_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurovum_sp_ar_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1165841"]),
        None,
        Some("."),
        Some("SULAR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pectobacterium sp. SCC3193 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1166016.W5S_0001";
/// let this_library_node_name2 = "1166016.W5S_4804";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pectobacterium_sp_scc3193_node_name(this_library_node_name1));
/// assert!(is_valid_string_pectobacterium_sp_scc3193_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pectobacterium_sp_scc3193_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pectobacterium_sp_scc3193_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1166016"]),
        None,
        Some("."),
        Some("W5S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fibrella aestuarina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1166018.FAES_0001";
/// let this_library_node_name2 = "1166018.FAES_pFAES01151";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fibrella_aestuarina_node_name(this_library_node_name1));
/// assert!(is_valid_string_fibrella_aestuarina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fibrella_aestuarina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fibrella_aestuarina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1166018"]),
        None,
        Some("."),
        Some("FAES_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacter sp. R4368 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1166130.H650_00005";
/// let this_library_node_name2 = "1166130.H650_24810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacter_sp_r4368_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacter_sp_r4368_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacter_sp_r4368_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacter_sp_r4368_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1166130"]),
        None,
        Some("."),
        Some("H650_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas xinjiangensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1166948.JPZL01000001_gene1885";
/// let this_library_node_name2 = "1166948.JPZL01000007_gene3313";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_xinjiangensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_xinjiangensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_xinjiangensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_xinjiangensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1166948"]),
        None,
        Some("."),
        Some("JPZL0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfocapsa sulfexigens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1167006.UWK_00004";
/// let this_library_node_name2 = "1167006.UWK_03572";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfocapsa_sulfexigens_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfocapsa_sulfexigens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfocapsa_sulfexigens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfocapsa_sulfexigens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1167006"]),
        None,
        Some("."),
        Some("UWK_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus vitulinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1167632.AJTR01000001_gene2519";
/// let this_library_node_name2 = "1167632.AJTR01000223_gene2368";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_vitulinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_vitulinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_vitulinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_vitulinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1167632"]),
        None,
        Some("."),
        Some("AJTR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Draconibacterium orientale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1168034.FH5T_00005";
/// let this_library_node_name2 = "1168034.FH5T_22140";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_draconibacterium_orientale_node_name(this_library_node_name1));
/// assert!(is_valid_string_draconibacterium_orientale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_draconibacterium_orientale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_draconibacterium_orientale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1168034"]),
        None,
        Some("."),
        Some("FH5T_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthobacteraceae bacterium 501b nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1168059.KB899087_gene1";
/// let this_library_node_name2 = "1168059.KB899088_gene4508";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthobacteraceae_bacterium_501b_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthobacteraceae_bacterium_501b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthobacteraceae_bacterium_501b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthobacteraceae_bacterium_501b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1168059"]),
        None,
        Some("."),
        Some("KB89908"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium BDW918 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1168065.DOK_00005";
/// let this_library_node_name2 = "1168065.DOK_19195";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_bdw918_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_bdw918_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_bdw918_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_bdw918_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1168065"]),
        None,
        Some("."),
        Some("DOK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiomicrospira kuenenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1168067.JAGP01000001_gene10";
/// let this_library_node_name2 = "1168067.JAGP01000002_gene8";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiomicrospira_kuenenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiomicrospira_kuenenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiomicrospira_kuenenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiomicrospira_kuenenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1168067"]),
        None,
        Some("."),
        Some("JAGP0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinilabilia salmonicolor nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1168289.AJKI01000001_gene3584";
/// let this_library_node_name2 = "1168289.AJKI01000071_gene3777";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinilabilia_salmonicolor_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinilabilia_salmonicolor_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinilabilia_salmonicolor_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinilabilia_salmonicolor_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1168289"]),
        None,
        Some("."),
        Some("AJKI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia bryophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1169143.KB911034_gene1000";
/// let this_library_node_name2 = "1169143.KB911065_gene3752";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_bryophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_bryophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_bryophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_bryophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1169143"]),
        None,
        Some("."),
        Some("KB9110"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. 123MFChir2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1169144.KB910924_gene270";
/// let this_library_node_name2 = "1169144.KB911033_gene2427";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_123mfchir2_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_123mfchir2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_123mfchir2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_123mfchir2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1169144"]),
        None,
        Some("."),
        Some("KB91"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia sp. CNY236 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1169152.AXVD01000001_gene2326";
/// let this_library_node_name2 = "1169152.AXVD01000081_gene2652";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_sp_cny236_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_sp_cny236_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_sp_cny236_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_sp_cny236_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1169152"]),
        None,
        Some("."),
        Some("AXVD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. CNT372 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1169154.KB897776_gene1572";
/// let this_library_node_name2 = "1169154.KB897815_gene78";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_cnt372_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_cnt372_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_cnt372_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_cnt372_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1169154"]),
        None,
        Some("."),
        Some("KB897"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. CNY243 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1169161.KB897713_gene6534";
/// let this_library_node_name2 = "1169161.KB897774_gene2803";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_cny243_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_cny243_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_cny243_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_cny243_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1169161"]),
        None,
        Some("."),
        Some("KB8977"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium avidum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1170318.PALO_00005";
/// let this_library_node_name2 = "1170318.PALO_11470";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_avidum_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_avidum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_avidum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_avidum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1170318"]),
        None,
        Some("."),
        Some("PALO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Calothrix sp. PCC6303 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1170562.Cal6303_0001";
/// let this_library_node_name2 = "1170562.Cal6303_R0012";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_calothrix_sp_pcc6303_node_name(this_library_node_name1));
/// assert!(is_valid_string_calothrix_sp_pcc6303_node_name(this_library_node_name2));
/// assert!(!is_valid_string_calothrix_sp_pcc6303_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_calothrix_sp_pcc6303_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1170562"]),
        None,
        Some("."),
        Some("Cal6303_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium acidipropionici nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1171373.PACID_00010";
/// let this_library_node_name2 = "1171373.PACID_34330";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_acidipropionici_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_acidipropionici_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_acidipropionici_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_acidipropionici_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1171373"]),
        None,
        Some("."),
        Some("PACID_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. 142MFCol31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1172179.AUKV01000001_gene1000";
/// let this_library_node_name2 = "1172179.AUKV01000097_gene7004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_142mfcol31_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_142mfcol31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_142mfcol31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_142mfcol31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1172179"]),
        None,
        Some("."),
        Some("AUKV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. 351MFTsu51 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1172180.KB911775_gene5760";
/// let this_library_node_name2 = "1172180.KB911819_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_351mftsu51_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_351mftsu51_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_351mftsu51_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_351mftsu51_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1172180"]),
        None,
        Some("."),
        Some("KB911"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. 303MFCol52 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1172181.KB911698_gene5561";
/// let this_library_node_name2 = "1172181.KB911774_gene6694";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_303mfcol52_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_303mfcol52_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_303mfcol52_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_303mfcol52_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1172181"]),
        None,
        Some("."),
        Some("KB911"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia sp. 348MFTsu51 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1172185.KB911509_gene100";
/// let this_library_node_name2 = "1172185.KB911543_gene4084";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_sp_348mftsu51_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_sp_348mftsu51_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_sp_348mftsu51_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_sp_348mftsu51_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1172185"]),
        None,
        Some("."),
        Some("KB9115"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium sp. 360MFTsu51 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1172186.KB911462_gene100";
/// let this_library_node_name2 = "1172186.KB911484_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_sp_360mftsu51_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_sp_360mftsu51_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_sp_360mftsu51_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_sp_360mftsu51_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1172186"]),
        None,
        Some("."),
        Some("KB9114"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Terracoccus sp. 273MFTsu31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1172188.KB911820_gene2086";
/// let this_library_node_name2 = "1172188.KB911835_gene3513";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_terracoccus_sp_273mftsu31_node_name(this_library_node_name1));
/// assert!(is_valid_string_terracoccus_sp_273mftsu31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_terracoccus_sp_273mftsu31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_terracoccus_sp_273mftsu31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1172188"]),
        None,
        Some("."),
        Some("KB9118"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurimonas sp. AST10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1172190.M947_00010";
/// let this_library_node_name2 = "1172190.M947_11750";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurimonas_sp_ast10_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurimonas_sp_ast10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurimonas_sp_ast10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurimonas_sp_ast10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1172190"]),
        None,
        Some("."),
        Some("M947_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter cinaedi PAGU611 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1172562.HCN_0001";
/// let this_library_node_name2 = "1172562.HCN_2096";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_cinaedi_pagu611_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_cinaedi_pagu611_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_cinaedi_pagu611_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_cinaedi_pagu611_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1172562"]),
        None,
        Some("."),
        Some("HCN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chamaesiphon minutus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173020.Cha6605_0001";
/// let this_library_node_name2 = "1173020.Cha6605_6413";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chamaesiphon_minutus_node_name(this_library_node_name1));
/// assert!(is_valid_string_chamaesiphon_minutus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chamaesiphon_minutus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chamaesiphon_minutus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173020"]),
        None,
        Some("."),
        Some("Cha6605_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanobacterium sp. PCC7702 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173021.ALWA01000001_gene2293";
/// let this_library_node_name2 = "1173021.ALWA01000042_gene2587";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanobacterium_sp_pcc7702_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanobacterium_sp_pcc7702_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanobacterium_sp_pcc7702_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanobacterium_sp_pcc7702_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173021"]),
        None,
        Some("."),
        Some("ALWA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Crinalium epipsammum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173022.Cri9333_0001";
/// let this_library_node_name2 = "1173022.Cri9333_R0026";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_crinalium_epipsammum_node_name(this_library_node_name1));
/// assert!(is_valid_string_crinalium_epipsammum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_crinalium_epipsammum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_crinalium_epipsammum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173022"]),
        None,
        Some("."),
        Some("Cri9333_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fischerella sp. PCC9431 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173023.KE650771_gene1";
/// let this_library_node_name2 = "1173023.KE650773_gene5663";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fischerella_sp_pcc9431_node_name(this_library_node_name1));
/// assert!(is_valid_string_fischerella_sp_pcc9431_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fischerella_sp_pcc9431_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fischerella_sp_pcc9431_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173023"]),
        None,
        Some("."),
        Some("KE65077"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fischerella sp. PCC9605 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173024.KI912148_gene2459";
/// let this_library_node_name2 = "1173024.KI912154_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fischerella_sp_pcc9605_node_name(this_library_node_name1));
/// assert!(is_valid_string_fischerella_sp_pcc9605_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fischerella_sp_pcc9605_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fischerella_sp_pcc9605_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173024"]),
        None,
        Some("."),
        Some("KI9121"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geitlerinema sp. PCC7407 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173025.GEI7407_0001";
/// let this_library_node_name2 = "1173025.GEI7407_R0060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geitlerinema_sp_pcc7407_node_name(this_library_node_name1));
/// assert!(is_valid_string_geitlerinema_sp_pcc7407_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geitlerinema_sp_pcc7407_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geitlerinema_sp_pcc7407_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173025"]),
        None,
        Some("."),
        Some("GEI7407_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gloeocapsa sp. PCC7428 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173026.Glo7428_0001";
/// let this_library_node_name2 = "1173026.Glo7428_R0011";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gloeocapsa_sp_pcc7428_node_name(this_library_node_name1));
/// assert!(is_valid_string_gloeocapsa_sp_pcc7428_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gloeocapsa_sp_pcc7428_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gloeocapsa_sp_pcc7428_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173026"]),
        None,
        Some("."),
        Some("Glo7428_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microcoleus sp. PCC7113 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173027.Mic7113_0001";
/// let this_library_node_name2 = "1173027.Mic7113_6656";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microcoleus_sp_pcc7113_node_name(this_library_node_name1));
/// assert!(is_valid_string_microcoleus_sp_pcc7113_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microcoleus_sp_pcc7113_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microcoleus_sp_pcc7113_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173027"]),
        None,
        Some("."),
        Some("Mic7113_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oscillatoria sp. PCC10802 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173028.ANKO01000001_gene5130";
/// let this_library_node_name2 = "1173028.ANKO01000253_gene1800";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oscillatoria_sp_pcc10802_node_name(this_library_node_name1));
/// assert!(is_valid_string_oscillatoria_sp_pcc10802_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oscillatoria_sp_pcc10802_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oscillatoria_sp_pcc10802_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173028"]),
        None,
        Some("."),
        Some("ANKO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirulina subsalsa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173029.JH980292_gene1";
/// let this_library_node_name2 = "1173029.JH980292_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirulina_subsalsa_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirulina_subsalsa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirulina_subsalsa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirulina_subsalsa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173029"]),
        None,
        Some("."),
        Some("JH980292_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. PCC7502 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173263.Syn7502_00001";
/// let this_library_node_name2 = "1173263.Syn7502_03658";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_pcc7502_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_pcc7502_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_pcc7502_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_pcc7502_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173263"]),
        None,
        Some("."),
        Some("Syn7502_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptolyngbya sp. PCC6406 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173264.KI913949_gene1";
/// let this_library_node_name2 = "1173264.KI913951_gene4704";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptolyngbya_sp_pcc6406_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptolyngbya_sp_pcc6406_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptolyngbya_sp_pcc6406_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptolyngbya_sp_pcc6406_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173264"]),
        None,
        Some("."),
        Some("KI9139"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Colletotrichum sublineola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1173701.A0A066WS76";
/// let this_library_node_name2 = "1173701.A0A066Y2Y2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_colletotrichum_sublineola_node_name(this_library_node_name1));
/// assert!(is_valid_string_colletotrichum_sublineola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_colletotrichum_sublineola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_colletotrichum_sublineola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1173701"]),
        None,
        Some("."),
        Some("A0A066"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus psychrosaccharolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1174504.AJTN02000001_gene2824";
/// let this_library_node_name2 = "1174504.AJTN02000265_gene342";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_psychrosaccharolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_psychrosaccharolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_psychrosaccharolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_psychrosaccharolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1174504"]),
        None,
        Some("."),
        Some("AJTN02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fischerella sp. PCC9339 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1174528.JH992886_gene6188";
/// let this_library_node_name2 = "1174528.JH992898_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fischerella_sp_pcc9339_node_name(this_library_node_name1));
/// assert!(is_valid_string_fischerella_sp_pcc9339_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fischerella_sp_pcc9339_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fischerella_sp_pcc9339_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1174528"]),
        None,
        Some("."),
        Some("JH9928"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Liberibacter asiaticus gxpsy nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1174529.WSI_00005";
/// let this_library_node_name2 = "1174529.WSI_05815";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_liberibacter_asiaticus_gxpsy_node_name(this_library_node_name1));
/// assert!(is_valid_string_liberibacter_asiaticus_gxpsy_node_name(this_library_node_name2));
/// assert!(!is_valid_string_liberibacter_asiaticus_gxpsy_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_liberibacter_asiaticus_gxpsy_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1174529"]),
        None,
        Some("."),
        Some("WSI_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingopyxis sp. MC1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1174684.EBMC1_00005";
/// let this_library_node_name2 = "1174684.EBMC1_17492";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingopyxis_sp_mc1_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingopyxis_sp_mc1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingopyxis_sp_mc1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingopyxis_sp_mc1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1174684"]),
        None,
        Some("."),
        Some("EBMC1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Herbaspirillum sp. GW103 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1175306.GWL_00010";
/// let this_library_node_name2 = "1175306.GWL_46580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_herbaspirillum_sp_gw103_node_name(this_library_node_name1));
/// assert!(is_valid_string_herbaspirillum_sp_gw103_node_name(this_library_node_name2));
/// assert!(!is_valid_string_herbaspirillum_sp_gw103_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_herbaspirillum_sp_gw103_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1175306"]),
        None,
        Some("."),
        Some("GWL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aerococcus viridans LL1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1175629.AJTG01000001_gene311";
/// let this_library_node_name2 = "1175629.AJTG01000031_gene1621";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aerococcus_viridans_ll1_node_name(this_library_node_name1));
/// assert!(is_valid_string_aerococcus_viridans_ll1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aerococcus_viridans_ll1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aerococcus_viridans_ll1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1175629"]),
        None,
        Some("."),
        Some("AJTG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacterium massiliense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1176165.CAJD01000001_gene1";
/// let this_library_node_name2 = "1176165.CAJD01000024_gene2048";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacterium_massiliense_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacterium_massiliense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacterium_massiliense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacterium_massiliense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1176165"]),
        None,
        Some("."),
        Some("CAJD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alcanivorax sp. 19m6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1177154.Y5S_00001";
/// let this_library_node_name2 = "1177154.Y5S_03778";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alcanivorax_sp_19m6_node_name(this_library_node_name1));
/// assert!(is_valid_string_alcanivorax_sp_19m6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alcanivorax_sp_19m6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alcanivorax_sp_19m6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1177154"]),
        None,
        Some("."),
        Some("Y5S_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alcanivorax hongdengensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1177179.A11A3_00005";
/// let this_library_node_name2 = "1177179.A11A3_17216";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alcanivorax_hongdengensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alcanivorax_hongdengensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alcanivorax_hongdengensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alcanivorax_hongdengensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1177179"]),
        None,
        Some("."),
        Some("A11A3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alcanivorax jadensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1177181.T9A_00001";
/// let this_library_node_name2 = "1177181.T9A_03266";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alcanivorax_jadensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alcanivorax_jadensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alcanivorax_jadensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alcanivorax_jadensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1177181"]),
        None,
        Some("."),
        Some("T9A_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium sp. C448 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1177594.MIC448_1000002";
/// let this_library_node_name2 = "1177594.MIC448_990004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_sp_c448_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_sp_c448_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_sp_c448_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_sp_c448_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1177594"]),
        None,
        Some("."),
        Some("MIC448_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thalassospira profundimaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1177928.TH2_00005";
/// let this_library_node_name2 = "1177928.TH2_20325";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thalassospira_profundimaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_thalassospira_profundimaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thalassospira_profundimaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thalassospira_profundimaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1177928"]),
        None,
        Some("."),
        Some("TH2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas sp. BJGMMB45 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1178482.BJB45_00015";
/// let this_library_node_name2 = "1178482.BJB45_21725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_sp_bjgmmb45_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_sp_bjgmmb45_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_sp_bjgmmb45_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_sp_bjgmmb45_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1178482"]),
        None,
        Some("."),
        Some("BJB45_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus xiamenensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1178537.BA1_00005";
/// let this_library_node_name2 = "1178537.BA1_18691";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_xiamenensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_xiamenensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_xiamenensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_xiamenensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1178537"]),
        None,
        Some("."),
        Some("BA1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. DW54 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1178540.BA70_00005";
/// let this_library_node_name2 = "1178540.BA70_20065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_dw54_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_dw54_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_dw54_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_dw54_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1178540"]),
        None,
        Some("."),
        Some("BA70_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arenitalea lutea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1178825.ALIH01000001_gene2261";
/// let this_library_node_name2 = "1178825.ALIH01000051_gene1208";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arenitalea_lutea_node_name(this_library_node_name1));
/// assert!(is_valid_string_arenitalea_lutea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arenitalea_lutea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arenitalea_lutea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1178825"]),
        None,
        Some("."),
        Some("ALIH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photodesmus blepharus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1179155.CF67_003019";
/// let this_library_node_name2 = "1179155.CF67_28001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photodesmus_blepharus_node_name(this_library_node_name1));
/// assert!(is_valid_string_photodesmus_blepharus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photodesmus_blepharus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photodesmus_blepharus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1179155"]),
        None,
        Some("."),
        Some("CF67_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus lentus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1179226.AJXO01000001_gene804";
/// let this_library_node_name2 = "1179226.AJXO01000169_gene1285";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_lentus_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_lentus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_lentus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_lentus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1179226"]),
        None,
        Some("."),
        Some("AJXO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharothrix espanaensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1179773.BN6_00010";
/// let this_library_node_name2 = "1179773.BN6_85470";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharothrix_espanaensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharothrix_espanaensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharothrix_espanaensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharothrix_espanaensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1179773"]),
        None,
        Some("."),
        Some("BN6_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma sp. G5847 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1179777.D500_0001";
/// let this_library_node_name2 = "1179777.D500_0911";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_sp_g5847_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_sp_g5847_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_sp_g5847_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_sp_g5847_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1179777"]),
        None,
        Some("."),
        Some("D500_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. M47T1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1179778.PMM47T1_00005";
/// let this_library_node_name2 = "1179778.PMM47T1_28770";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_m47t1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_m47t1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_m47t1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_m47t1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1179778"]),
        None,
        Some("."),
        Some("PMM47T1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cladophialophora psammophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1182553.XP_007738812.1";
/// let this_library_node_name2 = "1182553.XP_007752232.1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cladophialophora_psammophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_cladophialophora_psammophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cladophialophora_psammophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cladophialophora_psammophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1182553"]),
        None,
        Some("."),
        Some("XP_0077"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas pseudoalcaligenes CECT5344 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1182590.BN5_00001";
/// let this_library_node_name2 = "1182590.BN5_04437";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_pseudoalcaligenes_cect5344_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_pseudoalcaligenes_cect5344_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_pseudoalcaligenes_cect5344_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_pseudoalcaligenes_cect5344_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1182590"]),
        None,
        Some("."),
        Some("BN5_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pyrococcus sp. ST04 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1183377.Py04_0001";
/// let this_library_node_name2 = "1183377.Py04_1789";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pyrococcus_sp_st04_node_name(this_library_node_name1));
/// assert!(is_valid_string_pyrococcus_sp_st04_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pyrococcus_sp_st04_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pyrococcus_sp_st04_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1183377"]),
        None,
        Some("."),
        Some("Py04_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gloeobacter kilaueensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1183438.GKIL_0001";
/// let this_library_node_name2 = "1183438.GKIL_4508";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gloeobacter_kilaueensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gloeobacter_kilaueensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gloeobacter_kilaueensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gloeobacter_kilaueensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1183438"]),
        None,
        Some("."),
        Some("GKIL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermogladius cellulolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1184251.TCELL_0001";
/// let this_library_node_name2 = "1184251.TCELL_1417";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermogladius_cellulolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermogladius_cellulolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermogladius_cellulolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermogladius_cellulolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1184251"]),
        None,
        Some("."),
        Some("TCELL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bdellovibrio exovorus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1184267.A11Q_1";
/// let this_library_node_name2 = "1184267.A11Q_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bdellovibrio_exovorus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bdellovibrio_exovorus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bdellovibrio_exovorus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bdellovibrio_exovorus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1184267"]),
        None,
        Some("."),
        Some("A11Q_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Austwickia chelonae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1184607.AUCHE_01_00010";
/// let this_library_node_name2 = "1184607.AUCHE_33_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_austwickia_chelonae_node_name(this_library_node_name1));
/// assert!(is_valid_string_austwickia_chelonae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_austwickia_chelonae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_austwickia_chelonae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1184607"]),
        None,
        Some("."),
        Some("AUCHE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kineosphaera limosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1184609.KILIM_001_00010";
/// let this_library_node_name2 = "1184609.KILIM_166_00020";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kineosphaera_limosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_kineosphaera_limosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kineosphaera_limosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kineosphaera_limosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1184609"]),
        None,
        Some("."),
        Some("KILIM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sinorhizobium fredii USDA257 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1185652.USDA257_c00010";
/// let this_library_node_name2 = "1185652.USDA257_p06190";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sinorhizobium_fredii_usda257_node_name(this_library_node_name1));
/// assert!(is_valid_string_sinorhizobium_fredii_usda257_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sinorhizobium_fredii_usda257_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sinorhizobium_fredii_usda257_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1185652"]),
        None,
        Some("."),
        Some("USDA257_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Planococcus antarcticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1185653.A1A1_00005";
/// let this_library_node_name2 = "1185653.A1A1_19071";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_planococcus_antarcticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_planococcus_antarcticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_planococcus_antarcticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_planococcus_antarcticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1185653"]),
        None,
        Some("."),
        Some("A1A1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioclava dalianensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1185766.DL1_00005";
/// let this_library_node_name2 = "1185766.DL1_21190";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioclava_dalianensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioclava_dalianensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioclava_dalianensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioclava_dalianensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1185766"]),
        None,
        Some("."),
        Some("DL1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fibrisoma limi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1185876.BN8_00001";
/// let this_library_node_name2 = "1185876.BN8_06709";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fibrisoma_limi_node_name(this_library_node_name1));
/// assert!(is_valid_string_fibrisoma_limi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fibrisoma_limi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fibrisoma_limi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1185876"]),
        None,
        Some("."),
        Some("BN8_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blattabacterium sp. Bgi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1186051.BGIGA_001";
/// let this_library_node_name2 = "1186051.BGIGA_p004";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blattabacterium_sp_bgi_node_name(this_library_node_name1));
/// assert!(is_valid_string_blattabacterium_sp_bgi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blattabacterium_sp_bgi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blattabacterium_sp_bgi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1186051"]),
        None,
        Some("."),
        Some("BGIGA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio genomosp. nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1187848.AJYQ01000001_gene2461";
/// let this_library_node_name2 = "1187848.AJYQ01000156_gene3996";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_genomosp_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_genomosp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_genomosp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_genomosp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1187848"]),
        None,
        Some("."),
        Some("AJYQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodovulum sp. PH10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1187851.A33M_0001";
/// let this_library_node_name2 = "1187851.A33M_4499";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodovulum_sp_ph10_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodovulum_sp_ph10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodovulum_sp_ph10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodovulum_sp_ph10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1187851"]),
        None,
        Some("."),
        Some("A33M_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma auris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1188233.MAU_0010";
/// let this_library_node_name2 = "1188233.MAU_6660";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_auris_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_auris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_auris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_auris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1188233"]),
        None,
        Some("."),
        Some("MAU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma alkalescens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1188234.MALK_0010";
/// let this_library_node_name2 = "1188234.MALK_6660";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_alkalescens_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_alkalescens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_alkalescens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_alkalescens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1188234"]),
        None,
        Some("."),
        Some("MALK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma bovigenitalium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1188235.MBVG_0010";
/// let this_library_node_name2 = "1188235.MBVG_7370";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_bovigenitalium_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_bovigenitalium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_bovigenitalium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_bovigenitalium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1188235"]),
        None,
        Some("."),
        Some("MBVG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma arginini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1188236.MARG_0010";
/// let this_library_node_name2 = "1188236.MARG_5580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_arginini_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_arginini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_arginini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_arginini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1188236"]),
        None,
        Some("."),
        Some("MARG_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma ovipneumoniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1188239.MOVI_0010";
/// let this_library_node_name2 = "1188239.MOVI_7410";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_ovipneumoniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_ovipneumoniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_ovipneumoniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_ovipneumoniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1188239"]),
        None,
        Some("."),
        Some("MOVI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma yeatsii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1188240.MYEA_0010";
/// let this_library_node_name2 = "1188240.MYEA_7320";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_yeatsii_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_yeatsii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_yeatsii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_yeatsii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1188240"]),
        None,
        Some("."),
        Some("MYEA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ureaplasma diversum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1188241.UDIV_0020";
/// let this_library_node_name2 = "1188241.UDIV_7260";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ureaplasma_diversum_node_name(this_library_node_name1));
/// assert!(is_valid_string_ureaplasma_diversum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ureaplasma_diversum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ureaplasma_diversum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1188241"]),
        None,
        Some("."),
        Some("UDIV_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio rumoiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1188252.AJYK01000001_gene443";
/// let this_library_node_name2 = "1188252.AJYK01000122_gene1261";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_rumoiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_rumoiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_rumoiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_rumoiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1188252"]),
        None,
        Some("."),
        Some("AJYK01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodovulum sulfidophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1188256.BASI01000001_gene1000";
/// let this_library_node_name2 = "1188256.BASI01000009_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodovulum_sulfidophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodovulum_sulfidophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodovulum_sulfidophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodovulum_sulfidophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1188256"]),
        None,
        Some("."),
        Some("BASI0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Indibacter alkaliphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1189612.A33Q_0001";
/// let this_library_node_name2 = "1189612.A33Q_4696";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_indibacter_alkaliphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_indibacter_alkaliphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_indibacter_alkaliphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_indibacter_alkaliphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1189612"]),
        None,
        Some("."),
        Some("A33Q_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychroflexus gondwanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1189619.pgond44_00005";
/// let this_library_node_name2 = "1189619.pgond44_15018";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychroflexus_gondwanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychroflexus_gondwanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychroflexus_gondwanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychroflexus_gondwanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1189619"]),
        None,
        Some("."),
        Some("pgond44_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium sp. ACAM123 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1189620.AJXL01000001_gene1714";
/// let this_library_node_name2 = "1189620.AJXL01000284_gene3224";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_sp_acam123_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_sp_acam123_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_sp_acam123_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_sp_acam123_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1189620"]),
        None,
        Some("."),
        Some("AJXL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterovibrio norvegicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1190603.AJYD01000003_gene4316";
/// let this_library_node_name2 = "1190603.AJYD01000112_gene395";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterovibrio_norvegicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterovibrio_norvegicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterovibrio_norvegicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterovibrio_norvegicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1190603"]),
        None,
        Some("."),
        Some("AJYD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterovibrio calviensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1190606.AJYG01000001_gene1199";
/// let this_library_node_name2 = "1190606.AJYG01000211_gene934";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterovibrio_calviensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterovibrio_calviensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterovibrio_calviensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterovibrio_calviensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1190606"]),
        None,
        Some("."),
        Some("AJYG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio kanaloae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1191299.AJYX01000001_gene2044";
/// let this_library_node_name2 = "1191299.AJYX01000129_gene1182";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_kanaloae_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_kanaloae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_kanaloae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_kanaloae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1191299"]),
        None,
        Some("."),
        Some("AJYX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter venetianus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1191460.F959_00001";
/// let this_library_node_name2 = "1191460.F959_03320";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_venetianus_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_venetianus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_venetianus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_venetianus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1191460"]),
        None,
        Some("."),
        Some("F959_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Melioribacter roseus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1191523.MROS_0001";
/// let this_library_node_name2 = "1191523.MROS_2854";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_melioribacter_roseus_node_name(this_library_node_name1));
/// assert!(is_valid_string_melioribacter_roseus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_melioribacter_roseus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_melioribacter_roseus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1191523"]),
        None,
        Some("."),
        Some("MROS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chondromyces apiculatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1192034.CAP_0001";
/// let this_library_node_name2 = "1192034.CAP_9057";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chondromyces_apiculatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_chondromyces_apiculatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chondromyces_apiculatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chondromyces_apiculatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1192034"]),
        None,
        Some("."),
        Some("CAP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sp. lig30 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1192124.LIG30_0001";
/// let this_library_node_name2 = "1192124.LIG30_4996";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sp_lig30_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sp_lig30_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sp_lig30_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sp_lig30_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1192124"]),
        None,
        Some("."),
        Some("LIG30_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium xenophagum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1192759.AKIB01000001_gene674";
/// let this_library_node_name2 = "1192759.AKIB01000129_gene3208";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_xenophagum_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_xenophagum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_xenophagum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_xenophagum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1192759"]),
        None,
        Some("."),
        Some("AKIB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudaminobacter salicylatoxidans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1192868.CAIU01000001_gene1";
/// let this_library_node_name2 = "1192868.CAIU01000051_gene4474";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudaminobacter_salicylatoxidans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudaminobacter_salicylatoxidans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudaminobacter_salicylatoxidans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudaminobacter_salicylatoxidans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1192868"]),
        None,
        Some("."),
        Some("CAIU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parascardovia denticolens IPLA20019 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1193128.A200_00005";
/// let this_library_node_name2 = "1193128.A200_08483";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parascardovia_denticolens_ipla20019_node_name(this_library_node_name1));
/// assert!(is_valid_string_parascardovia_denticolens_ipla20019_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parascardovia_denticolens_ipla20019_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parascardovia_denticolens_ipla20019_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1193128"]),
        None,
        Some("."),
        Some("A200_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tetrasphaera elongata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1193181.BN10_1000001";
/// let this_library_node_name2 = "1193181.BN10_990032";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tetrasphaera_elongata_node_name(this_library_node_name1));
/// assert!(is_valid_string_tetrasphaera_elongata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tetrasphaera_elongata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tetrasphaera_elongata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1193181"]),
        None,
        Some("."),
        Some("BN10_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Endolissoclinum faulkneri L2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1193729.A1OE_1";
/// let this_library_node_name2 = "1193729.A1OE_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_endolissoclinum_faulkneri_l2_node_name(this_library_node_name1));
/// assert!(is_valid_string_endolissoclinum_faulkneri_l2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_endolissoclinum_faulkneri_l2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_endolissoclinum_faulkneri_l2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1193729"]),
        None,
        Some("."),
        Some("A1OE_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium yannicii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1194165.CAJF01000001_gene1844";
/// let this_library_node_name2 = "1194165.CAJF01000067_gene1809";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_yannicii_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_yannicii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_yannicii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_yannicii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1194165"]),
        None,
        Some("."),
        Some("CAJF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus warneri SG1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1194526.A284_00005";
/// let this_library_node_name2 = "1194526.A284_12352";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_warneri_sg1_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_warneri_sg1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_warneri_sg1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_warneri_sg1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1194526"]),
        None,
        Some("."),
        Some("A284_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium vaccae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1194972.MVAC_00005";
/// let this_library_node_name2 = "1194972.MVAC_29975";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_vaccae_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_vaccae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_vaccae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_vaccae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1194972"]),
        None,
        Some("."),
        Some("MVAC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium termitidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1195236.CTER_0001";
/// let this_library_node_name2 = "1195236.CTER_5589";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_termitidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_termitidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_termitidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_termitidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1195236"]),
        None,
        Some("."),
        Some("CTER_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alishewanella agri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1195246.AGRI_00005";
/// let this_library_node_name2 = "1195246.AGRI_16005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alishewanella_agri_node_name(this_library_node_name1));
/// assert!(is_valid_string_alishewanella_agri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alishewanella_agri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alishewanella_agri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1195246"]),
        None,
        Some("."),
        Some("AGRI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Virgibacillus halodenitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1196028.ALEF01000001_gene1901";
/// let this_library_node_name2 = "1196028.ALEF01000092_gene806";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_virgibacillus_halodenitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_virgibacillus_halodenitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_virgibacillus_halodenitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_virgibacillus_halodenitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1196028"]),
        None,
        Some("."),
        Some("ALEF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus endophyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1196029.ALIM01000001_gene4937";
/// let this_library_node_name2 = "1196029.ALIM01000054_gene135";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_endophyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_endophyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_endophyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_endophyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1196029"]),
        None,
        Some("."),
        Some("ALIM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus oceanisediminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1196031.ALEG01000001_gene4461";
/// let this_library_node_name2 = "1196031.ALEG01000077_gene5436";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_oceanisediminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_oceanisediminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_oceanisediminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_oceanisediminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1196031"]),
        None,
        Some("."),
        Some("ALEG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Snodgrassella alvi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1196083.SALWKB12_0001";
/// let this_library_node_name2 = "1196083.SALWKB12_2303";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_snodgrassella_alvi_node_name(this_library_node_name1));
/// assert!(is_valid_string_snodgrassella_alvi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_snodgrassella_alvi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_snodgrassella_alvi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1196083"]),
        None,
        Some("."),
        Some("SALWKB12_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gilliamella apicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1196095.GAPWK_0001";
/// let this_library_node_name2 = "1196095.GAPWK_2809";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gilliamella_apicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_gilliamella_apicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gilliamella_apicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gilliamella_apicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1196095"]),
        None,
        Some("."),
        Some("GAPWK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. Maddingley nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1196322.A370_00001";
/// let this_library_node_name2 = "1196322.A370_05931";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_maddingley_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_maddingley_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_maddingley_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_maddingley_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1196322"]),
        None,
        Some("."),
        Some("A370_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. OSYSE nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1196323.ALKF01000001_gene4893";
/// let this_library_node_name2 = "1196323.ALKF01000205_gene4344";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_osyse_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_osyse_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_osyse_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_osyse_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1196323"]),
        None,
        Some("."),
        Some("ALKF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus macauensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1196324.A374_00005";
/// let this_library_node_name2 = "1196324.A374_19480";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_macauensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_macauensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_macauensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_macauensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1196324"]),
        None,
        Some("."),
        Some("A374_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas stutzeri CCUG 29243 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1196835.A458_00005";
/// let this_library_node_name2 = "1196835.A458_21795";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_stutzeri_ccug_29243_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_stutzeri_ccug_29243_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_stutzeri_ccug_29243_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_stutzeri_ccug_29243_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1196835"]),
        None,
        Some("."),
        Some("A458_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halococcus sp. 197A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1197130.BAFM01000001_gene1";
/// let this_library_node_name2 = "1197130.BAFM01000046_gene3271";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halococcus_sp_197a_node_name(this_library_node_name1));
/// assert!(is_valid_string_halococcus_sp_197a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halococcus_sp_197a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halococcus_sp_197a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1197130"]),
        None,
        Some("."),
        Some("BAFM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mangrovimonas yunxiaonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1197477.IA57_00005";
/// let this_library_node_name2 = "1197477.IA57_12770";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mangrovimonas_yunxiaonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_mangrovimonas_yunxiaonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mangrovimonas_yunxiaonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mangrovimonas_yunxiaonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1197477"]),
        None,
        Some("."),
        Some("IA57_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. M2012083 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1197706.AKKK01000001_gene1752";
/// let this_library_node_name2 = "1197706.AKKK01000067_gene3832";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_m2012083_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_m2012083_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_m2012083_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_m2012083_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1197706"]),
        None,
        Some("."),
        Some("AKKK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salmonella bongori N26808 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1197719.A464_1";
/// let this_library_node_name2 = "1197719.A464_plas0132";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salmonella_bongori_n26808_node_name(this_library_node_name1));
/// assert!(is_valid_string_salmonella_bongori_n26808_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salmonella_bongori_n26808_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salmonella_bongori_n26808_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1197719"]),
        None,
        Some("."),
        Some("A464_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Afipia birgiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1197906.CAJQ02000001_gene2622";
/// let this_library_node_name2 = "1197906.CAJQ02000065_gene4239";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_afipia_birgiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_afipia_birgiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_afipia_birgiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_afipia_birgiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1197906"]),
        None,
        Some("."),
        Some("CAJQ020000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Granulicella tundricola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1198114.AciX9_0001";
/// let this_library_node_name2 = "1198114.AciX9_4593";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_granulicella_tundricola_node_name(this_library_node_name1));
/// assert!(is_valid_string_granulicella_tundricola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_granulicella_tundricola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_granulicella_tundricola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1198114"]),
        None,
        Some("."),
        Some("AciX9_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cycloclasticus zancles nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1198232.CYCME_0001";
/// let this_library_node_name2 = "1198232.CYCME_3052";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cycloclasticus_zancles_node_name(this_library_node_name1));
/// assert!(is_valid_string_cycloclasticus_zancles_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cycloclasticus_zancles_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cycloclasticus_zancles_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1198232"]),
        None,
        Some("."),
        Some("CYCME_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aeropyrum camini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1198449.ACAM_0001";
/// let this_library_node_name2 = "1198449.ACAM_1645";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aeropyrum_camini_node_name(this_library_node_name1));
/// assert!(is_valid_string_aeropyrum_camini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aeropyrum_camini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aeropyrum_camini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1198449"]),
        None,
        Some("."),
        Some("ACAM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Janthinobacterium sp. HH01 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1198452.Jab_1c00020";
/// let this_library_node_name2 = "1198452.Jab_2c35400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_janthinobacterium_sp_hh01_node_name(this_library_node_name1));
/// assert!(is_valid_string_janthinobacterium_sp_hh01_node_name(this_library_node_name2));
/// assert!(!is_valid_string_janthinobacterium_sp_hh01_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_janthinobacterium_sp_hh01_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1198452"]),
        None,
        Some("."),
        Some("Jab_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus mutans GS5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1198676.SMUGS5_00005";
/// let this_library_node_name2 = "1198676.SMUGS5_09745";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_mutans_gs5_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_mutans_gs5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_mutans_gs5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_mutans_gs5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1198676"]),
        None,
        Some("."),
        Some("SMUGS5_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium terpenotabidum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1200352.A606_00005";
/// let this_library_node_name2 = "1200352.A606_11940";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_terpenotabidum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_terpenotabidum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_terpenotabidum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_terpenotabidum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1200352"]),
        None,
        Some("."),
        Some("A606_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerovibrio sp. RM50 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1200557.JHWV01000001_gene254";
/// let this_library_node_name2 = "1200557.JHWV01000045_gene651";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerovibrio_sp_rm50_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerovibrio_sp_rm50_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerovibrio_sp_rm50_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerovibrio_sp_rm50_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1200557"]),
        None,
        Some("."),
        Some("JHWV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminobacter sp. RM87 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1200567.JNKD01000001_gene1657";
/// let this_library_node_name2 = "1200567.JNKD01000128_gene968";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminobacter_sp_rm87_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminobacter_sp_rm87_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminobacter_sp_rm87_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminobacter_sp_rm87_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1200567"]),
        None,
        Some("."),
        Some("JNKD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacillus brevis X23 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1200792.AKYF01000001_gene3827";
/// let this_library_node_name2 = "1200792.AKYF01000029_gene5";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacillus_brevis_x23_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacillus_brevis_x23_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacillus_brevis_x23_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacillus_brevis_x23_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1200792"]),
        None,
        Some("."),
        Some("AKYF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella birtlesii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1201035.KE007210_gene1000";
/// let this_library_node_name2 = "1201035.KE007215_gene1437";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_birtlesii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_birtlesii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_birtlesii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_birtlesii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1201035"]),
        None,
        Some("."),
        Some("KE00721"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteriovorax sp. Seq25V nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1201288.M900_0001";
/// let this_library_node_name2 = "1201288.M900_A0502";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteriovorax_sp_seq25v_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteriovorax_sp_seq25v_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteriovorax_sp_seq25v_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteriovorax_sp_seq25v_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1201288"]),
        None,
        Some("."),
        Some("M900_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteriovorax sp. BAL6X nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1201290.M902_0225";
/// let this_library_node_name2 = "1201290.M902_3331";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteriovorax_sp_bal6x_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteriovorax_sp_bal6x_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteriovorax_sp_bal6x_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteriovorax_sp_bal6x_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1201290"]),
        None,
        Some("."),
        Some("M902_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus faecalis ATCC29212 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1201292.DR75_1";
/// let this_library_node_name2 = "1201292.DR75_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_faecalis_atcc29212_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_faecalis_atcc29212_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_faecalis_atcc29212_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_faecalis_atcc29212_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1201292"]),
        None,
        Some("."),
        Some("DR75_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moritella dasanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1201293.AKXQ01000001_gene1872";
/// let this_library_node_name2 = "1201293.AKXQ01000061_gene1080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moritella_dasanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_moritella_dasanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moritella_dasanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moritella_dasanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1201293"]),
        None,
        Some("."),
        Some("AKXQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium sp. F52 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1202532.FF52_00005";
/// let this_library_node_name2 = "1202532.FF52_22979";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_sp_f52_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_sp_f52_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_sp_f52_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_sp_f52_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1202532"]),
        None,
        Some("."),
        Some("FF52_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halopiger salifodinae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1202768.JROF01000001_gene1502";
/// let this_library_node_name2 = "1202768.JROF01000081_gene1475";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halopiger_salifodinae_node_name(this_library_node_name1));
/// assert!(is_valid_string_halopiger_salifodinae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halopiger_salifodinae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halopiger_salifodinae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1202768"]),
        None,
        Some("."),
        Some("JROF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moritella marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1202962.KB907150_gene1347";
/// let this_library_node_name2 = "1202962.KB907207_gene2934";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moritella_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_moritella_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moritella_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moritella_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1202962"]),
        None,
        Some("."),
        Some("KB907"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus ingluviei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203076.CAKF01000001_gene1028";
/// let this_library_node_name2 = "1203076.CAKF01000040_gene1021";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_ingluviei_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_ingluviei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_ingluviei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_ingluviei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203076"]),
        None,
        Some("."),
        Some("CAKF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium timonense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203190.CAJP01000001_gene1685";
/// let this_library_node_name2 = "1203190.CAJP01000053_gene2177";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_timonense_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_timonense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_timonense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_timonense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203190"]),
        None,
        Some("."),
        Some("CAJP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella oralis HGA0225 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203550.HMPREF1475_00001";
/// let this_library_node_name2 = "1203550.HMPREF1475_02419";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_oralis_hga0225_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_oralis_hga0225_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_oralis_hga0225_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_oralis_hga0225_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203550"]),
        None,
        Some("."),
        Some("HMPREF1475_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sutterella wadsworthensis HGA0223 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203554.HMPREF1476_00003";
/// let this_library_node_name2 = "1203554.HMPREF1476_02488";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sutterella_wadsworthensis_hga0223_node_name(this_library_node_name1));
/// assert!(is_valid_string_sutterella_wadsworthensis_hga0223_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sutterella_wadsworthensis_hga0223_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sutterella_wadsworthensis_hga0223_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203554"]),
        None,
        Some("."),
        Some("HMPREF1476_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. HPA0247 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203556.HMPREF1478_00004";
/// let this_library_node_name2 = "1203556.HMPREF1478_02065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_hpa0247_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_hpa0247_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_hpa0247_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_hpa0247_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203556"]),
        None,
        Some("."),
        Some("HMPREF1478_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium sp. KPL1859 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203566.HMPREF1285_00001";
/// let this_library_node_name2 = "1203566.HMPREF1285_02416";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_sp_kpl1859_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_sp_kpl1859_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_sp_kpl1859_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_sp_kpl1859_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203566"]),
        None,
        Some("."),
        Some("HMPREF1285_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium sp. KPL1860 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203567.HMPREF1286_00003";
/// let this_library_node_name2 = "1203567.HMPREF1286_02397";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_sp_kpl1860_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_sp_kpl1860_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_sp_kpl1860_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_sp_kpl1860_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203567"]),
        None,
        Some("."),
        Some("HMPREF1286_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dermabacter sp. HFH0086 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203568.HMPREF1484_00004";
/// let this_library_node_name2 = "1203568.HMPREF1484_02189";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dermabacter_sp_hfh0086_node_name(this_library_node_name1));
/// assert!(is_valid_string_dermabacter_sp_hfh0086_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dermabacter_sp_hfh0086_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dermabacter_sp_hfh0086_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203568"]),
        None,
        Some("."),
        Some("HMPREF1484_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. HPH0090 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203590.HMPREF1481_00022";
/// let this_library_node_name2 = "1203590.HMPREF1481_01732";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_hph0090_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_hph0090_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_hph0090_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_hph0090_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203590"]),
        None,
        Some("."),
        Some("HMPREF1481_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atopobium sp. F0494 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203602.HMPREF1527_00004";
/// let this_library_node_name2 = "1203602.HMPREF1527_01529";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atopobium_sp_f0494_node_name(this_library_node_name1));
/// assert!(is_valid_string_atopobium_sp_f0494_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atopobium_sp_f0494_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atopobium_sp_f0494_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203602"]),
        None,
        Some("."),
        Some("HMPREF1527_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium sp. F0372 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203605.HMPREF1531_00004";
/// let this_library_node_name2 = "1203605.HMPREF1531_02582";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_sp_f0372_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_sp_f0372_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_sp_f0372_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_sp_f0372_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203605"]),
        None,
        Some("."),
        Some("HMPREF1531_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyricicoccus pullicaecorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203606.HMPREF1526_00005";
/// let this_library_node_name2 = "1203606.HMPREF1526_03198";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyricicoccus_pullicaecorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyricicoccus_pullicaecorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyricicoccus_pullicaecorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyricicoccus_pullicaecorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203606"]),
        None,
        Some("."),
        Some("HMPREF1526_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alistipes onderdonkii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203611.KB894541_gene1166";
/// let this_library_node_name2 = "1203611.KB894569_gene1944";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alistipes_onderdonkii_node_name(this_library_node_name1));
/// assert!(is_valid_string_alistipes_onderdonkii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alistipes_onderdonkii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alistipes_onderdonkii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203611"]),
        None,
        Some("."),
        Some("KB8945"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium sp. KPL1989 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203622.HMPREF1290_00004";
/// let this_library_node_name2 = "1203622.HMPREF1290_02133";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_sp_kpl1989_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_sp_kpl1989_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_sp_kpl1989_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_sp_kpl1989_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203622"]),
        None,
        Some("."),
        Some("HMPREF1290_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium sp. KPL2004 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1203632.HMPREF1300_00002";
/// let this_library_node_name2 = "1203632.HMPREF1300_02450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_sp_kpl2004_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_sp_kpl2004_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_sp_kpl2004_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_sp_kpl2004_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1203632"]),
        None,
        Some("."),
        Some("HMPREF1300_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Reyranella massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1205680.CAKO01000001_gene3130";
/// let this_library_node_name2 = "1205680.CAKO01000042_gene5504";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_reyranella_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_reyranella_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_reyranella_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_reyranella_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1205680"]),
        None,
        Some("."),
        Some("CAKO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella rattaustraliani nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1205681.CALW02000001_gene1913";
/// let this_library_node_name2 = "1205681.CALW02000108_gene1921";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_rattaustraliani_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_rattaustraliani_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_rattaustraliani_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_rattaustraliani_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1205681"]),
        None,
        Some("."),
        Some("CALW02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yersinia massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1205683.CAKR01000001_gene2095";
/// let this_library_node_name2 = "1205683.CAKR01000060_gene2585";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yersinia_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_yersinia_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yersinia_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yersinia_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1205683"]),
        None,
        Some("."),
        Some("CAKR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas translucens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1205753.A989_00005";
/// let this_library_node_name2 = "1205753.A989_19708";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_translucens_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_translucens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_translucens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_translucens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1205753"]),
        None,
        Some("."),
        Some("A989_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio breoganii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1205908.AKXW01000001_gene3208";
/// let this_library_node_name2 = "1205908.AKXW01000177_gene3047";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_breoganii_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_breoganii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_breoganii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_breoganii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1205908"]),
        None,
        Some("."),
        Some("AKXW01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardiopsis alba nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1205910.B005_0002";
/// let this_library_node_name2 = "1205910.B005_5606";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardiopsis_alba_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardiopsis_alba_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardiopsis_alba_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardiopsis_alba_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1205910"]),
        None,
        Some("."),
        Some("B005_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. CNR698 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206101.AZXC01000001_gene4173";
/// let this_library_node_name2 = "1206101.AZXC01000076_gene5155";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_cnr698_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_cnr698_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_cnr698_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_cnr698_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206101"]),
        None,
        Some("."),
        Some("AZXC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia aobensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206720.BAFQ01000001_gene1";
/// let this_library_node_name2 = "1206720.BAFQ01000298_gene6852";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_aobensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_aobensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_aobensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_aobensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206720"]),
        None,
        Some("."),
        Some("BAFQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia brevicatena nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206725.BAFU01000001_gene4932";
/// let this_library_node_name2 = "1206725.BAFU01000248_gene3286";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_brevicatena_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_brevicatena_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_brevicatena_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_brevicatena_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206725"]),
        None,
        Some("."),
        Some("BAFU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia carnea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206726.BAFV01000001_gene1";
/// let this_library_node_name2 = "1206726.BAFV01000126_gene6774";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_carnea_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_carnea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_carnea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_carnea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206726"]),
        None,
        Some("."),
        Some("BAFV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia exalbida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206729.BAFZ01000001_gene1";
/// let this_library_node_name2 = "1206729.BAFZ01000165_gene5824";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_exalbida_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_exalbida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_exalbida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_exalbida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206729"]),
        None,
        Some("."),
        Some("BAFZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia higoensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206730.BAGA01000001_gene582";
/// let this_library_node_name2 = "1206730.BAGA01000185_gene3661";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_higoensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_higoensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_higoensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_higoensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206730"]),
        None,
        Some("."),
        Some("BAGA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia jiangxiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206731.BAGB01000001_gene9304";
/// let this_library_node_name2 = "1206731.BAGB01000174_gene2150";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_jiangxiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_jiangxiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_jiangxiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_jiangxiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206731"]),
        None,
        Some("."),
        Some("BAGB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia otitidiscaviarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206732.BAGD01000002_gene1";
/// let this_library_node_name2 = "1206732.BAGD01000281_gene6790";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_otitidiscaviarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_otitidiscaviarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_otitidiscaviarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_otitidiscaviarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206732"]),
        None,
        Some("."),
        Some("BAGD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia niigatensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206733.BAGC01000001_gene5594";
/// let this_library_node_name2 = "1206733.BAGC01000114_gene7274";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_niigatensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_niigatensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_niigatensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_niigatensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206733"]),
        None,
        Some("."),
        Some("BAGC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia takedensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206735.BAGG01000001_gene1";
/// let this_library_node_name2 = "1206735.BAGG01000266_gene7089";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_takedensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_takedensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_takedensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_takedensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206735"]),
        None,
        Some("."),
        Some("BAGG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia pneumoniae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206737.BAGF01000001_gene1";
/// let this_library_node_name2 = "1206737.BAGF01000152_gene6543";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_pneumoniae_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_pneumoniae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_pneumoniae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_pneumoniae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206737"]),
        None,
        Some("."),
        Some("BAGF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia testacea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206739.BAGJ01000001_gene6182";
/// let this_library_node_name2 = "1206739.BAGJ01000274_gene3954";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_testacea_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_testacea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_testacea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_testacea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206739"]),
        None,
        Some("."),
        Some("BAGJ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia concava nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206741.BAFX01000001_gene5527";
/// let this_library_node_name2 = "1206741.BAFX01000206_gene413";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_concava_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_concava_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_concava_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_concava_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206741"]),
        None,
        Some("."),
        Some("BAFX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia veterana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206743.BAGM01000001_gene4344";
/// let this_library_node_name2 = "1206743.BAGM01000210_gene448";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_veterana_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_veterana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_veterana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_veterana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206743"]),
        None,
        Some("."),
        Some("BAGM01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia transvalensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206744.BAGL01000001_gene4010";
/// let this_library_node_name2 = "1206744.BAGL01000128_gene7027";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_transvalensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_transvalensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_transvalensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_transvalensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206744"]),
        None,
        Some("."),
        Some("BAGL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. Lz4W nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1206777.B195_00005";
/// let this_library_node_name2 = "1206777.B195_22407";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_lz4w_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_lz4w_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_lz4w_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_lz4w_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1206777"]),
        None,
        Some("."),
        Some("B195_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium sp. C100 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1207055.C100_00005";
/// let this_library_node_name2 = "1207055.C100_23750";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_sp_c100_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_sp_c100_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_sp_c100_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_sp_c100_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1207055"]),
        None,
        Some("."),
        Some("C100_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas sp. L53140 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1207058.L53_00010";
/// let this_library_node_name2 = "1207058.L53_16600";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_sp_l53140_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_sp_l53140_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_sp_l53140_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_sp_l53140_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1207058"]),
        None,
        Some("."),
        Some("L53_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanibaculum indicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1207063.P24_00005";
/// let this_library_node_name2 = "1207063.P24_18889";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanibaculum_indicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanibaculum_indicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanibaculum_indicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanibaculum_indicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1207063"]),
        None,
        Some("."),
        Some("P24_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. UW4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1207075.PputUW4_00001";
/// let this_library_node_name2 = "1207075.PputUW4_05443";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_uw4_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_uw4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_uw4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_uw4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1207075"]),
        None,
        Some("."),
        Some("PputUW4_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas luteola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1207076.ALAT01000001_gene1830";
/// let this_library_node_name2 = "1207076.ALAT01000231_gene653";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_luteola_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_luteola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_luteola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_luteola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1207076"]),
        None,
        Some("."),
        Some("ALAT01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinomonas sp. D104 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1208321.D104_00010";
/// let this_library_node_name2 = "1208321.D104_18535";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinomonas_sp_d104_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinomonas_sp_d104_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinomonas_sp_d104_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinomonas_sp_d104_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1208321"]),
        None,
        Some("."),
        Some("D104_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Celeribacter baekdonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1208323.B30_00005";
/// let this_library_node_name2 = "1208323.B30_21164";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_celeribacter_baekdonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_celeribacter_baekdonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_celeribacter_baekdonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_celeribacter_baekdonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1208323"]),
        None,
        Some("."),
        Some("B30_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Commensalibacter sp. MX01 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1208583.COMX_00005";
/// let this_library_node_name2 = "1208583.COMX_10405";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_commensalibacter_sp_mx01_node_name(this_library_node_name1));
/// assert!(is_valid_string_commensalibacter_sp_mx01_node_name(this_library_node_name2));
/// assert!(!is_valid_string_commensalibacter_sp_mx01_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_commensalibacter_sp_mx01_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1208583"]),
        None,
        Some("."),
        Some("COMX_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kinetoplastibacterium crithidii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1208918.CDEE_0001";
/// let this_library_node_name2 = "1208918.CDEE_0903";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kinetoplastibacterium_crithidii_node_name(this_library_node_name1));
/// assert!(is_valid_string_kinetoplastibacterium_crithidii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kinetoplastibacterium_crithidii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kinetoplastibacterium_crithidii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1208918"]),
        None,
        Some("."),
        Some("CDEE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kinetoplastibacterium desouzaii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1208919.CDSE_0001";
/// let this_library_node_name2 = "1208919.CDSE_0886";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kinetoplastibacterium_desouzaii_node_name(this_library_node_name1));
/// assert!(is_valid_string_kinetoplastibacterium_desouzaii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kinetoplastibacterium_desouzaii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kinetoplastibacterium_desouzaii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1208919"]),
        None,
        Some("."),
        Some("CDSE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kinetoplastibacterium oncopeltii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1208920.CONE_0001";
/// let this_library_node_name2 = "1208920.CONE_0846";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kinetoplastibacterium_oncopeltii_node_name(this_library_node_name1));
/// assert!(is_valid_string_kinetoplastibacterium_oncopeltii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kinetoplastibacterium_oncopeltii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kinetoplastibacterium_oncopeltii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1208920"]),
        None,
        Some("."),
        Some("CONE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kinetoplastibacterium galatii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1208921.ST1E_0001";
/// let this_library_node_name2 = "1208921.ST1E_0990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kinetoplastibacterium_galatii_node_name(this_library_node_name1));
/// assert!(is_valid_string_kinetoplastibacterium_galatii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kinetoplastibacterium_galatii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kinetoplastibacterium_galatii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1208921"]),
        None,
        Some("."),
        Some("ST1E_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kinetoplastibacterium blastocrithidii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1208923.CKBE_00001";
/// let this_library_node_name2 = "1208923.CKBE_00769";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kinetoplastibacterium_blastocrithidii_node_name(this_library_node_name1));
/// assert!(is_valid_string_kinetoplastibacterium_blastocrithidii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kinetoplastibacterium_blastocrithidii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kinetoplastibacterium_blastocrithidii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1208923"]),
        None,
        Some("."),
        Some("CKBE_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellvibrio mixtus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1209072.ALBT01000001_gene662";
/// let this_library_node_name2 = "1209072.ALBT01000152_gene660";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellvibrio_mixtus_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellvibrio_mixtus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellvibrio_mixtus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellvibrio_mixtus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1209072"]),
        None,
        Some("."),
        Some("ALBT01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium mageritense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1209984.BN978_00002";
/// let this_library_node_name2 = "1209984.BN978_07795";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_mageritense_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_mageritense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_mageritense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_mageritense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1209984"]),
        None,
        Some("."),
        Some("BN978_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tepidanaerobacter acetatoxydans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1209989.TepiRe1_0001";
/// let this_library_node_name2 = "1209989.TepiRe1_2852";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tepidanaerobacter_acetatoxydans_node_name(this_library_node_name1));
/// assert!(is_valid_string_tepidanaerobacter_acetatoxydans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tepidanaerobacter_acetatoxydans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tepidanaerobacter_acetatoxydans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1209989"]),
        None,
        Some("."),
        Some("TepiRe1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. AA0539 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1210045.ALNP01000001_gene2942";
/// let this_library_node_name2 = "1210045.ALNP01000057_gene5092";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_aa0539_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_aa0539_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_aa0539_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_aa0539_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1210045"]),
        None,
        Some("."),
        Some("ALNP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Janibacter hoylei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1210046.B277_00005";
/// let this_library_node_name2 = "1210046.B277_16312";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_janibacter_hoylei_node_name(this_library_node_name1));
/// assert!(is_valid_string_janibacter_hoylei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_janibacter_hoylei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_janibacter_hoylei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1210046"]),
        None,
        Some("."),
        Some("B277_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemmata sp. IIL30 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1210884.HG799462_gene7780";
/// let this_library_node_name2 = "1210884.HG799483_gene15528";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemmata_sp_iil30_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemmata_sp_iil30_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemmata_sp_iil30_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemmata_sp_iil30_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1210884"]),
        None,
        Some("."),
        Some("HG7994"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halogranum salarium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1210908.HSB1_00010";
/// let this_library_node_name2 = "1210908.HSB1_48240";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halogranum_salarium_node_name(this_library_node_name1));
/// assert!(is_valid_string_halogranum_salarium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halogranum_salarium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halogranum_salarium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1210908"]),
        None,
        Some("."),
        Some("HSB1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysinibacillus massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211035.CD30_00010";
/// let this_library_node_name2 = "1211035.CD30_20100";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysinibacillus_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysinibacillus_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysinibacillus_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysinibacillus_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211035"]),
        None,
        Some("."),
        Some("CD30_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas psychrophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211112.ALJC01000001_gene4537";
/// let this_library_node_name2 = "1211112.ALJC01000145_gene2231";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_psychrophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_psychrophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_psychrophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_psychrophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211112"]),
        None,
        Some("."),
        Some("ALJC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoxanthomonas sp. GW2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211114.ALIP01000001_gene512";
/// let this_library_node_name2 = "1211114.ALIP01000167_gene468";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoxanthomonas_sp_gw2_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoxanthomonas_sp_gw2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoxanthomonas_sp_gw2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoxanthomonas_sp_gw2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211114"]),
        None,
        Some("."),
        Some("ALIP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chelatococcus sp. GW1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211115.ALIQ01000001_gene1488";
/// let this_library_node_name2 = "1211115.ALIQ01000247_gene31";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chelatococcus_sp_gw1_node_name(this_library_node_name1));
/// assert!(is_valid_string_chelatococcus_sp_gw1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chelatococcus_sp_gw1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chelatococcus_sp_gw1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211115"]),
        None,
        Some("."),
        Some("ALIQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas putida NBRC14164 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211579.PP4_00010";
/// let this_library_node_name2 = "1211579.PP4_54490";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_putida_nbrc14164_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_putida_nbrc14164_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_putida_nbrc14164_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_putida_nbrc14164_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211579"]),
        None,
        Some("."),
        Some("PP4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium mesoamericanum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211777.BN77_0001";
/// let this_library_node_name2 = "1211777.BN77_p60014";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_mesoamericanum_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_mesoamericanum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_mesoamericanum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_mesoamericanum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211777"]),
        None,
        Some("."),
        Some("BN77_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alistipes marseilloanorexicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211813.CAPH01000001_gene1145";
/// let this_library_node_name2 = "1211813.CAPH01000058_gene14";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alistipes_marseilloanorexicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_alistipes_marseilloanorexicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alistipes_marseilloanorexicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alistipes_marseilloanorexicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211813"]),
        None,
        Some("."),
        Some("CAPH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus massilioanorexius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211814.CAPG01000001_gene1";
/// let this_library_node_name2 = "1211814.CAPG01000120_gene4423";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_massilioanorexius_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_massilioanorexius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_massilioanorexius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_massilioanorexius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211814"]),
        None,
        Some("."),
        Some("CAPG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blastococcus massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211815.CBYP010000001_gene2001";
/// let this_library_node_name2 = "1211815.CBYP010000076_gene2041";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blastococcus_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_blastococcus_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blastococcus_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blastococcus_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211815"]),
        None,
        Some("."),
        Some("CBYP0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium anorexicamassiliense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211817.CCAT010000001_gene209";
/// let this_library_node_name2 = "1211817.CCAT010000096_gene2166";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_anorexicamassiliense_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_anorexicamassiliense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_anorexicamassiliense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_anorexicamassiliense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211817"]),
        None,
        Some("."),
        Some("CCAT0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Holdemania massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211819.CALK01000001_gene324";
/// let this_library_node_name2 = "1211819.CALK01000066_gene3103";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_holdemania_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_holdemania_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_holdemania_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_holdemania_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211819"]),
        None,
        Some("."),
        Some("CALK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stoquefichus massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1211844.CBLM010000001_gene606";
/// let this_library_node_name2 = "1211844.CBLM010000166_gene48";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stoquefichus_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_stoquefichus_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stoquefichus_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stoquefichus_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1211844"]),
        None,
        Some("."),
        Some("CBLM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas stutzeri NF13 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1212548.B381_00005";
/// let this_library_node_name2 = "1212548.B381_21841";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_stutzeri_nf13_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_stutzeri_nf13_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_stutzeri_nf13_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_stutzeri_nf13_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1212548"]),
        None,
        Some("."),
        Some("B381_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacteriaceae bacterium B14 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1214065.BAGV01000001_gene423";
/// let this_library_node_name2 = "1214065.BAGV01000275_gene1987";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacteriaceae_bacterium_b14_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacteriaceae_bacterium_b14_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacteriaceae_bacterium_b14_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacteriaceae_bacterium_b14_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1214065"]),
        None,
        Some("."),
        Some("BAGV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces davawensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1214101.BN159_0001";
/// let this_library_node_name2 = "1214101.BN159_p99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_davawensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_davawensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_davawensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_davawensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1214101"]),
        None,
        Some("."),
        Some("BN159_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus suis 865192 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1214166.ALLG01000001_gene1561";
/// let this_library_node_name2 = "1214166.ALLG01000055_gene1526";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_suis_865192_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_suis_865192_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_suis_865192_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_suis_865192_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1214166"]),
        None,
        Some("."),
        Some("ALLG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus suis 22083 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1214184.ALKY01000001_gene29";
/// let this_library_node_name2 = "1214184.ALKY01000042_gene1872";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_suis_22083_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_suis_22083_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_suis_22083_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_suis_22083_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1214184"]),
        None,
        Some("."),
        Some("ALKY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus suis YS72 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1214217.ALNF01000001_gene1931";
/// let this_library_node_name2 = "1214217.ALNF01000078_gene1223";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_suis_ys72_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_suis_ys72_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_suis_ys72_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_suis_ys72_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1214217"]),
        None,
        Some("."),
        Some("ALNF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces collinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1214242.B446_00005";
/// let this_library_node_name2 = "1214242.B446_35843";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_collinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_collinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_collinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_collinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1214242"]),
        None,
        Some("."),
        Some("B446_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas alcaligenes NBRC14159 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1215092.PA6_001_00010";
/// let this_library_node_name2 = "1215092.PA6_121_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_alcaligenes_nbrc14159_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_alcaligenes_nbrc14159_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_alcaligenes_nbrc14159_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_alcaligenes_nbrc14159_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1215092"]),
        None,
        Some("."),
        Some("PA6_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas parafulva nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1215114.BBIU01000001_gene1";
/// let this_library_node_name2 = "1215114.BBIU01000055_gene4286";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_parafulva_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_parafulva_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_parafulva_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_parafulva_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1215114"]),
        None,
        Some("."),
        Some("BBIU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Liberibacter crescens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1215343.B488_00000";
/// let this_library_node_name2 = "1215343.B488_13780";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_liberibacter_crescens_node_name(this_library_node_name1));
/// assert!(is_valid_string_liberibacter_crescens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_liberibacter_crescens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_liberibacter_crescens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1215343"]),
        None,
        Some("."),
        Some("B488_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactococcus raffinolactis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1215915.BN193_00005";
/// let this_library_node_name2 = "1215915.BN193_12090";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactococcus_raffinolactis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactococcus_raffinolactis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactococcus_raffinolactis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactococcus_raffinolactis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1215915"]),
        None,
        Some("."),
        Some("BN193_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas ruthenica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1216007.AOPM01000001_gene2649";
/// let this_library_node_name2 = "1216007.AOPM01000120_gene826";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_ruthenica_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_ruthenica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_ruthenica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_ruthenica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1216007"]),
        None,
        Some("."),
        Some("AOPM01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium hwasookii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1216362.B437_00005";
/// let this_library_node_name2 = "1216362.B437_11159";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_hwasookii_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_hwasookii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_hwasookii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_hwasookii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1216362"]),
        None,
        Some("."),
        Some("B437_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. M240 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1216932.CM240_0001";
/// let this_library_node_name2 = "1216932.CM240_3374";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_m240_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_m240_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_m240_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_m240_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1216932"]),
        None,
        Some("."),
        Some("CM240_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Edwardsiella hoshinae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1216966.BAUC01000001_gene1781";
/// let this_library_node_name2 = "1216966.BAUC01000110_gene2706";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_edwardsiella_hoshinae_node_name(this_library_node_name1));
/// assert!(is_valid_string_edwardsiella_hoshinae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_edwardsiella_hoshinae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_edwardsiella_hoshinae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1216966"]),
        None,
        Some("."),
        Some("BAUC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Elizabethkingia meningoseptica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1216967.L100_00005";
/// let this_library_node_name2 = "1216967.L100_17185";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_elizabethkingia_meningoseptica_node_name(this_library_node_name1));
/// assert!(is_valid_string_elizabethkingia_meningoseptica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_elizabethkingia_meningoseptica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_elizabethkingia_meningoseptica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1216967"]),
        None,
        Some("."),
        Some("L100_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Achromobacter xylosoxidans NBRC15126 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1216976.AX27061_0001";
/// let this_library_node_name2 = "1216976.AX27061_6081";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_achromobacter_xylosoxidans_nbrc15126_node_name(this_library_node_name1));
/// assert!(is_valid_string_achromobacter_xylosoxidans_nbrc15126_node_name(this_library_node_name2));
/// assert!(!is_valid_string_achromobacter_xylosoxidans_nbrc15126_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_achromobacter_xylosoxidans_nbrc15126_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1216976"]),
        None,
        Some("."),
        Some("AX27061_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter beijerinckii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217648.F933_00001";
/// let this_library_node_name2 = "1217648.F933_03406";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_beijerinckii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_beijerinckii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_beijerinckii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_beijerinckii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217648"]),
        None,
        Some("."),
        Some("F933_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter brisouii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217652.F954_00001";
/// let this_library_node_name2 = "1217652.F954_02998";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_brisouii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_brisouii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_brisouii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_brisouii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217652"]),
        None,
        Some("."),
        Some("F954_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter guillouiae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217656.F964_00002";
/// let this_library_node_name2 = "1217656.F964_04593";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_guillouiae_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_guillouiae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_guillouiae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_guillouiae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217656"]),
        None,
        Some("."),
        Some("F964_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter gyllenbergii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217658.F987_00001";
/// let this_library_node_name2 = "1217658.F987_04453";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_gyllenbergii_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_gyllenbergii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_gyllenbergii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_gyllenbergii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217658"]),
        None,
        Some("."),
        Some("F987_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. ANC4105 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217703.F904_00001";
/// let this_library_node_name2 = "1217703.F904_03913";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_anc4105_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_anc4105_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_anc4105_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_anc4105_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217703"]),
        None,
        Some("."),
        Some("F904_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. ANC3862 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217705.F900_00001";
/// let this_library_node_name2 = "1217705.F900_03731";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_anc3862_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_anc3862_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_anc3862_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_anc3862_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217705"]),
        None,
        Some("."),
        Some("F900_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. NIPH2100 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217708.F887_00001";
/// let this_library_node_name2 = "1217708.F887_03667";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_niph2100_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_niph2100_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_niph2100_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_niph2100_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217708"]),
        None,
        Some("."),
        Some("F887_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. NIPH899 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217710.F969_00001";
/// let this_library_node_name2 = "1217710.F969_03820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_niph899_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_niph899_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_niph899_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_niph899_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217710"]),
        None,
        Some("."),
        Some("F969_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. NIPH758 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217712.F971_00001";
/// let this_library_node_name2 = "1217712.F971_03847";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_niph758_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_niph758_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_niph758_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_niph758_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217712"]),
        None,
        Some("."),
        Some("F971_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. NIPH809 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217713.F993_00001";
/// let this_library_node_name2 = "1217713.F993_04011";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_niph809_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_niph809_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_niph809_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_niph809_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217713"]),
        None,
        Some("."),
        Some("F993_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. ANC3789 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217714.F975_00001";
/// let this_library_node_name2 = "1217714.F975_03108";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_anc3789_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_anc3789_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_anc3789_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_anc3789_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217714"]),
        None,
        Some("."),
        Some("F975_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter bohemicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217715.F994_00001";
/// let this_library_node_name2 = "1217715.F994_03425";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_bohemicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_bohemicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_bohemicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_bohemicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217715"]),
        None,
        Some("."),
        Some("F994_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cupriavidus sp. BIS7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217718.ALOU01000001_gene4531";
/// let this_library_node_name2 = "1217718.ALOU01000138_gene2968";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cupriavidus_sp_bis7_node_name(this_library_node_name1));
/// assert!(is_valid_string_cupriavidus_sp_bis7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cupriavidus_sp_bis7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cupriavidus_sp_bis7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217718"]),
        None,
        Some("."),
        Some("ALOU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseomonas sp. B5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1217720.ALOX01000001_gene3376";
/// let this_library_node_name2 = "1217720.ALOX01000228_gene3563";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseomonas_sp_b5_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseomonas_sp_b5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseomonas_sp_b5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseomonas_sp_b5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1217720"]),
        None,
        Some("."),
        Some("ALOX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia acidipaludis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1218074.BAXZ01000001_gene1";
/// let this_library_node_name2 = "1218074.BAXZ01000064_gene5479";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_acidipaludis_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_acidipaludis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_acidipaludis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_acidipaludis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1218074"]),
        None,
        Some("."),
        Some("BAXZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia bannensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1218075.BAYA01000001_gene1";
/// let this_library_node_name2 = "1218075.BAYA01000101_gene7173";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_bannensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_bannensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_bannensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_bannensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1218075"]),
        None,
        Some("."),
        Some("BAYA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia ferrariae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1218076.BAYB01000001_gene1";
/// let this_library_node_name2 = "1218076.BAYB01000097_gene6487";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_ferrariae_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_ferrariae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_ferrariae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_ferrariae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1218076"]),
        None,
        Some("."),
        Some("BAYB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia terrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1218084.BBJK01000001_gene1";
/// let this_library_node_name2 = "1218084.BBJK01000246_gene8209";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_terrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_terrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_terrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_terrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1218084"]),
        None,
        Some("."),
        Some("BBJK01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Citrobacter sedlakii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1218086.BBNB01000001_gene3267";
/// let this_library_node_name2 = "1218086.BBNB01000030_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_citrobacter_sedlakii_node_name(this_library_node_name1));
/// assert!(is_valid_string_citrobacter_sedlakii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_citrobacter_sedlakii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_citrobacter_sedlakii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1218086"]),
        None,
        Some("."),
        Some("BBNB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium indologenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1218103.CIN01S_01_00010";
/// let this_library_node_name2 = "1218103.CIN01S_32_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_indologenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_indologenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_indologenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_indologenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1218103"]),
        None,
        Some("."),
        Some("CIN01S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Empedobacter brevis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1218108.KB908291_gene1000";
/// let this_library_node_name2 = "1218108.KB908318_gene395";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_empedobacter_brevis_node_name(this_library_node_name1));
/// assert!(is_valid_string_empedobacter_brevis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_empedobacter_brevis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_empedobacter_brevis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1218108"]),
        None,
        Some("."),
        Some("KB908"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus alcalophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1218173.BALCAV_0200010";
/// let this_library_node_name2 = "1218173.BALCAV_0222655";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_alcalophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_alcalophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_alcalophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_alcalophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1218173"]),
        None,
        Some("."),
        Some("BALCAV_02"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas stutzeri KOS6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1218352.B597_000005";
/// let this_library_node_name2 = "1218352.B597_022990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_stutzeri_kos6_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_stutzeri_kos6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_stutzeri_kos6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_stutzeri_kos6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1218352"]),
        None,
        Some("."),
        Some("B597_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Comamonas aquatica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219031.BBJR01000001_gene467";
/// let this_library_node_name2 = "1219031.BBJR01000103_gene445";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_comamonas_aquatica_node_name(this_library_node_name1));
/// assert!(is_valid_string_comamonas_aquatica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_comamonas_aquatica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_comamonas_aquatica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219031"]),
        None,
        Some("."),
        Some("BBJR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novosphingobium tardaugens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219035.NT2_01_00010";
/// let this_library_node_name2 = "1219035.NT2_54_00020";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novosphingobium_tardaugens_node_name(this_library_node_name1));
/// assert!(is_valid_string_novosphingobium_tardaugens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novosphingobium_tardaugens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novosphingobium_tardaugens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219035"]),
        None,
        Some("."),
        Some("NT2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium herbicidovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219045.BV98_000001";
/// let this_library_node_name2 = "1219045.BV98_003977";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_herbicidovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_herbicidovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_herbicidovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_herbicidovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219045"]),
        None,
        Some("."),
        Some("BV98_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas parapaucimobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219049.SP5_001_00020";
/// let this_library_node_name2 = "1219049.SP5_126_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_parapaucimobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_parapaucimobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_parapaucimobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_parapaucimobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219049"]),
        None,
        Some("."),
        Some("SP5_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio proteolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219065.VPR01S_01_00010";
/// let this_library_node_name2 = "1219065.VPR01S_50_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_proteolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_proteolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_proteolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_proteolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219065"]),
        None,
        Some("."),
        Some("VPR01S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio halioticoli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219072.VHA01S_002_00010";
/// let this_library_node_name2 = "1219072.VHA01S_108_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_halioticoli_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_halioticoli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_halioticoli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_halioticoli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219072"]),
        None,
        Some("."),
        Some("VHA01S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio alginolyticus NBRC15630 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219076.N646_0001";
/// let this_library_node_name2 = "1219076.N646_4722";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_alginolyticus_nbrc15630_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_alginolyticus_nbrc15630_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_alginolyticus_nbrc15630_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_alginolyticus_nbrc15630_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219076"]),
        None,
        Some("."),
        Some("N646_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio azureus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219077.VAZ01S_001_00020";
/// let this_library_node_name2 = "1219077.VAZ01S_166_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_azureus_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_azureus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_azureus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_azureus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219077"]),
        None,
        Some("."),
        Some("VAZ01S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio ezurae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219080.VEZ01S_01_00010";
/// let this_library_node_name2 = "1219080.VEZ01S_64_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_ezurae_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_ezurae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_ezurae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_ezurae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219080"]),
        None,
        Some("."),
        Some("VEZ01S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermotoga hypogea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219084.AP014508_gene1";
/// let this_library_node_name2 = "1219084.AP014508_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermotoga_hypogea_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermotoga_hypogea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermotoga_hypogea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermotoga_hypogea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219084"]),
        None,
        Some("."),
        Some("AP014508_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas cassavae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219375.CM002139_gene1";
/// let this_library_node_name2 = "1219375.CM002140_gene4264";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_cassavae_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_cassavae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_cassavae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_cassavae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219375"]),
        None,
        Some("."),
        Some("CM0021"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. S4C9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219581.HMPREF1628_00010";
/// let this_library_node_name2 = "1219581.HMPREF1628_08685";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_s4c9_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_s4c9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_s4c9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_s4c9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219581"]),
        None,
        Some("."),
        Some("HMPREF1628_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arcanobacterium sp. S3PF19 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219585.HMPREF1631_00005";
/// let this_library_node_name2 = "1219585.HMPREF1631_07230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arcanobacterium_sp_s3pf19_node_name(this_library_node_name1));
/// assert!(is_valid_string_arcanobacterium_sp_s3pf19_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arcanobacterium_sp_s3pf19_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arcanobacterium_sp_s3pf19_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219585"]),
        None,
        Some("."),
        Some("HMPREF1631_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptostreptococcus sp. MV1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1219626.HMPREF1639_00010";
/// let this_library_node_name2 = "1219626.HMPREF1639_09230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptostreptococcus_sp_mv1_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptostreptococcus_sp_mv1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptostreptococcus_sp_mv1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptostreptococcus_sp_mv1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1219626"]),
        None,
        Some("."),
        Some("HMPREF1639_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanobacterium sp. Maddingley nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1220534.B655_0004";
/// let this_library_node_name2 = "1220534.B655_2471";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanobacterium_sp_maddingley_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanobacterium_sp_maddingley_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanobacterium_sp_maddingley_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanobacterium_sp_maddingley_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1220534"]),
        None,
        Some("."),
        Some("B655_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING alpha proteobacterium IMCC14465 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1220535.IMCC14465_00010";
/// let this_library_node_name2 = "1220535.IMCC14465_18950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alpha_proteobacterium_imcc14465_node_name(this_library_node_name1));
/// assert!(is_valid_string_alpha_proteobacterium_imcc14465_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alpha_proteobacterium_imcc14465_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alpha_proteobacterium_imcc14465_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1220535"]),
        None,
        Some("."),
        Some("IMCC14465_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus chromogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1220551.SCHR_00005";
/// let this_library_node_name2 = "1220551.SCHR_11469";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_chromogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_chromogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_chromogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_chromogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1220551"]),
        None,
        Some("."),
        Some("SCHR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium rubi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1220582.RRU01S_01_00010";
/// let this_library_node_name2 = "1220582.RRU01S_55_00020";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_rubi_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_rubi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_rubi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_rubi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1220582"]),
        None,
        Some("."),
        Some("RRU01S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia aichiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1220583.GOACH_01_00010";
/// let this_library_node_name2 = "1220583.GOACH_78_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_aichiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_aichiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_aichiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_aichiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1220583"]),
        None,
        Some("."),
        Some("GOACH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysinibacillus odysseyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1220589.CD32_00055";
/// let this_library_node_name2 = "1220589.CD32_23615";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysinibacillus_odysseyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysinibacillus_odysseyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysinibacillus_odysseyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysinibacillus_odysseyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1220589"]),
        None,
        Some("."),
        Some("CD32_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas fluorescens NCIMB11764 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1221522.B723_00010";
/// let this_library_node_name2 = "1221522.B723_32870";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_fluorescens_ncimb11764_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_fluorescens_ncimb11764_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_fluorescens_ncimb11764_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_fluorescens_ncimb11764_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1221522"]),
        None,
        Some("."),
        Some("B723_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus florum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1221537.B807_1";
/// let this_library_node_name2 = "1221537.B807_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_florum_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_florum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_florum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_florum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1221537"]),
        None,
        Some("."),
        Some("B807_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Altibacter lentus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1223410.KN050846_gene1";
/// let this_library_node_name2 = "1223410.KN050846_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_altibacter_lentus_node_name(this_library_node_name1));
/// assert!(is_valid_string_altibacter_lentus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_altibacter_lentus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_altibacter_lentus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1223410"]),
        None,
        Some("."),
        Some("KN050846_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Comamonas granuli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1223521.BBJX01000001_gene1000";
/// let this_library_node_name2 = "1223521.BBJX01000034_gene220";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_comamonas_granuli_node_name(this_library_node_name1));
/// assert!(is_valid_string_comamonas_granuli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_comamonas_granuli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_comamonas_granuli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1223521"]),
        None,
        Some("."),
        Some("BBJX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces mobaraensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1223523.H340_00005";
/// let this_library_node_name2 = "1223523.H340_32332";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_mobaraensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_mobaraensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_mobaraensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_mobaraensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1223523"]),
        None,
        Some("."),
        Some("H340_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia malaquae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1223542.GM1_001_00010";
/// let this_library_node_name2 = "1223542.GM1_115_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_malaquae_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_malaquae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_malaquae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_malaquae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1223542"]),
        None,
        Some("."),
        Some("GM1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia paraffinivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1223543.GP2_001_00010";
/// let this_library_node_name2 = "1223543.GP2_109_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_paraffinivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_paraffinivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_paraffinivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_paraffinivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1223543"]),
        None,
        Some("."),
        Some("GP2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia sihwensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1223544.GSI01S_01_00010";
/// let this_library_node_name2 = "1223544.GSI01S_61_00010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_sihwensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_sihwensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_sihwensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_sihwensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1223544"]),
        None,
        Some("."),
        Some("GSI01S_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia soli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1223545.GS4_01_00010";
/// let this_library_node_name2 = "1223545.GS4_57_00030";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_soli_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_soli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_soli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_soli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1223545"]),
        None,
        Some("."),
        Some("GS4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacteriaceae bacterium LSJC7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1224136.AMFN01000001_gene3752";
/// let this_library_node_name2 = "1224136.AMFN01000033_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacteriaceae_bacterium_lsjc7_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacteriaceae_bacterium_lsjc7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacteriaceae_bacterium_lsjc7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacteriaceae_bacterium_lsjc7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1224136"]),
        None,
        Some("."),
        Some("AMFN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium maris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1224163.B841_00005";
/// let this_library_node_name2 = "1224163.B841_13111";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_maris_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_maris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_maris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_maris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1224163"]),
        None,
        Some("."),
        Some("B841_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium vitaeruminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1224164.B843_00005";
/// let this_library_node_name2 = "1224164.B843_12985";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_vitaeruminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_vitaeruminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_vitaeruminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_vitaeruminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1224164"]),
        None,
        Some("."),
        Some("B843_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mangrovibacter sp. MFB070 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1224318.DT73_00015";
/// let this_library_node_name2 = "1224318.DT73_26325";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mangrovibacter_sp_mfb070_node_name(this_library_node_name1));
/// assert!(is_valid_string_mangrovibacter_sp_mfb070_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mangrovibacter_sp_mfb070_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mangrovibacter_sp_mfb070_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1224318"]),
        None,
        Some("."),
        Some("DT73_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gluconobacter oxydans H24 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1224746.B932_0001";
/// let this_library_node_name2 = "1224746.B932_3806";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gluconobacter_oxydans_h24_node_name(this_library_node_name1));
/// assert!(is_valid_string_gluconobacter_oxydans_h24_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gluconobacter_oxydans_h24_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gluconobacter_oxydans_h24_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1224746"]),
        None,
        Some("."),
        Some("B932_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea sp. A4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1225184.ALXE01000001_gene2881";
/// let this_library_node_name2 = "1225184.ALXE01000072_gene4359";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_sp_a4_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_sp_a4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_sp_a4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_sp_a4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1225184"]),
        None,
        Some("."),
        Some("ALXE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dickeya sp. DW 0440 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1225785.CM001983_gene1";
/// let this_library_node_name2 = "1225785.CM001983_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dickeya_sp_dw_0440_node_name(this_library_node_name1));
/// assert!(is_valid_string_dickeya_sp_dw_0440_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dickeya_sp_dw_0440_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dickeya_sp_dw_0440_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1225785"]),
        None,
        Some("."),
        Some("CM001983_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oscillibacter sp. KLE1728 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1226322.HMPREF1545_00001";
/// let this_library_node_name2 = "1226322.HMPREF1545_04328";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oscillibacter_sp_kle1728_node_name(this_library_node_name1));
/// assert!(is_valid_string_oscillibacter_sp_kle1728_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oscillibacter_sp_kle1728_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oscillibacter_sp_kle1728_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1226322"]),
        None,
        Some("."),
        Some("HMPREF1545_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. KLE1755 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1226325.HMPREF1548_00001";
/// let this_library_node_name2 = "1226325.HMPREF1548_07016";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_kle1755_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_kle1755_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_kle1755_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_kle1755_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1226325"]),
        None,
        Some("."),
        Some("HMPREF1548_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas nitroreducens TX1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1226994.AMZB01000001_gene976";
/// let this_library_node_name2 = "1226994.AMZB01000138_gene5803";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_nitroreducens_tx1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_nitroreducens_tx1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_nitroreducens_tx1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_nitroreducens_tx1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1226994"]),
        None,
        Some("."),
        Some("AMZB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinobaculum sp. F0552 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227261.HMPREF0043_00001";
/// let this_library_node_name2 = "1227261.HMPREF0043_02369";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobaculum_sp_f0552_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobaculum_sp_f0552_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobaculum_sp_f0552_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobaculum_sp_f0552_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227261"]),
        None,
        Some("."),
        Some("HMPREF0043_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Capnocytophaga sp. F0517 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227266.HMPREF1551_00001";
/// let this_library_node_name2 = "1227266.HMPREF1551_02829";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_capnocytophaga_sp_f0517_node_name(this_library_node_name1));
/// assert!(is_valid_string_capnocytophaga_sp_f0517_node_name(this_library_node_name2));
/// assert!(!is_valid_string_capnocytophaga_sp_f0517_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_capnocytophaga_sp_f0517_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227266"]),
        None,
        Some("."),
        Some("HMPREF1551_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptotrichia sp. F0557 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227268.HMPREF1552_00001";
/// let this_library_node_name2 = "1227268.HMPREF1552_02522";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptotrichia_sp_f0557_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptotrichia_sp_f0557_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptotrichia_sp_f0557_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptotrichia_sp_f0557_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227268"]),
        None,
        Some("."),
        Some("HMPREF1552_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas sp. W7784 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227272.HMPREF1556_00003";
/// let this_library_node_name2 = "1227272.HMPREF1556_02041";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_sp_w7784_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_sp_w7784_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_sp_w7784_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_sp_w7784_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227272"]),
        None,
        Some("."),
        Some("HMPREF1556_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. F0091 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227276.HMPREF9148_00001";
/// let this_library_node_name2 = "1227276.HMPREF9148_02961";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_f0091_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_f0091_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_f0091_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_f0091_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227276"]),
        None,
        Some("."),
        Some("HMPREF9148_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. FSLH7689 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227349.C170_00019";
/// let this_library_node_name2 = "1227349.C170_29823";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_fslh7689_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_fslh7689_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_fslh7689_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_fslh7689_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227349"]),
        None,
        Some("."),
        Some("C170_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. FSLR7277 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227352.C173_00005";
/// let this_library_node_name2 = "1227352.C173_32421";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_fslr7277_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_fslr7277_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_fslr7277_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_fslr7277_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227352"]),
        None,
        Some("."),
        Some("C173_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Viridibacillus arenosi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227360.C176_00005";
/// let this_library_node_name2 = "1227360.C176_21731";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_viridibacillus_arenosi_node_name(this_library_node_name1));
/// assert!(is_valid_string_viridibacillus_arenosi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_viridibacillus_arenosi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_viridibacillus_arenosi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227360"]),
        None,
        Some("."),
        Some("C176_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloarcula japonica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227453.C444_00005";
/// let this_library_node_name2 = "1227453.C444_21506";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloarcula_japonica_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloarcula_japonica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloarcula_japonica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloarcula_japonica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227453"]),
        None,
        Some("."),
        Some("C444_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halobiforma nitratireducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227454.C446_00005";
/// let this_library_node_name2 = "1227454.C446_18166";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halobiforma_nitratireducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_halobiforma_nitratireducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halobiforma_nitratireducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halobiforma_nitratireducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227454"]),
        None,
        Some("."),
        Some("C446_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halococcus thailandensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227457.C451_00005";
/// let this_library_node_name2 = "1227457.C451_20797";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halococcus_thailandensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_halococcus_thailandensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halococcus_thailandensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halococcus_thailandensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227457"]),
        None,
        Some("."),
        Some("C451_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halorubrum saccharovorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227484.C471_00005";
/// let this_library_node_name2 = "1227484.C471_16377";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halorubrum_saccharovorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_halorubrum_saccharovorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halorubrum_saccharovorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halorubrum_saccharovorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227484"]),
        None,
        Some("."),
        Some("C471_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halosarcina pallida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227487.C474_00005";
/// let this_library_node_name2 = "1227487.C474_21606";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halosarcina_pallida_node_name(this_library_node_name1));
/// assert!(is_valid_string_halosarcina_pallida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halosarcina_pallida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halosarcina_pallida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227487"]),
        None,
        Some("."),
        Some("C474_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloterrigena salina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227488.C477_00005";
/// let this_library_node_name2 = "1227488.C477_23296";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloterrigena_salina_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloterrigena_salina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloterrigena_salina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloterrigena_salina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227488"]),
        None,
        Some("."),
        Some("C477_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natrinema pallidum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227495.C487_00005";
/// let this_library_node_name2 = "1227495.C487_19763";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natrinema_pallidum_node_name(this_library_node_name1));
/// assert!(is_valid_string_natrinema_pallidum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natrinema_pallidum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natrinema_pallidum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227495"]),
        None,
        Some("."),
        Some("C487_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natronococcus amylolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227497.C491_00005";
/// let this_library_node_name2 = "1227497.C491_21990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natronococcus_amylolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_natronococcus_amylolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natronococcus_amylolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natronococcus_amylolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227497"]),
        None,
        Some("."),
        Some("C491_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natronolimnobius innermongolicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227499.C493_00005";
/// let this_library_node_name2 = "1227499.C493_22281";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natronolimnobius_innermongolicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_natronolimnobius_innermongolicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natronolimnobius_innermongolicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natronolimnobius_innermongolicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227499"]),
        None,
        Some("."),
        Some("C493_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natronorubrum bangense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227500.C494_00005";
/// let this_library_node_name2 = "1227500.C494_20488";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natronorubrum_bangense_node_name(this_library_node_name1));
/// assert!(is_valid_string_natronorubrum_bangense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natronorubrum_bangense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natronorubrum_bangense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227500"]),
        None,
        Some("."),
        Some("C494_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hymenobacter swuensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1227739.Hsw_0001";
/// let this_library_node_name2 = "1227739.Hsw_PC0006";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hymenobacter_swuensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_hymenobacter_swuensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hymenobacter_swuensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hymenobacter_swuensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1227739"]),
        None,
        Some("."),
        Some("Hsw_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptolyngbya sp. KIOST1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229172.JQFA01000001_gene2024";
/// let this_library_node_name2 = "1229172.JQFA01000013_gene5192";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptolyngbya_sp_kiost1_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptolyngbya_sp_kiost1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptolyngbya_sp_kiost1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptolyngbya_sp_kiost1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229172"]),
        None,
        Some("."),
        Some("JQFA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING actinobacterium LLX17 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229203.KI301992_gene1";
/// let this_library_node_name2 = "1229203.KI301992_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobacterium_llx17_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobacterium_llx17_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobacterium_llx17_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobacterium_llx17_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229203"]),
        None,
        Some("."),
        Some("KI301992_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING alpha proteobacterium L41A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229204.AMYY01000001_gene2684";
/// let this_library_node_name2 = "1229204.AMYY01000067_gene2311";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alpha_proteobacterium_l41a_node_name(this_library_node_name1));
/// assert!(is_valid_string_alpha_proteobacterium_l41a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alpha_proteobacterium_l41a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alpha_proteobacterium_l41a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229204"]),
        None,
        Some("."),
        Some("AMYY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia phenoliruptrix nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229205.BUPH_00001";
/// let this_library_node_name2 = "1229205.BUPH_08564";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_phenoliruptrix_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_phenoliruptrix_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_phenoliruptrix_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_phenoliruptrix_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229205"]),
        None,
        Some("."),
        Some("BUPH_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobacterium sp. ACCC05744 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229276.DI53_0001";
/// let this_library_node_name2 = "1229276.DI53_3969";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobacterium_sp_accc05744_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobacterium_sp_accc05744_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobacterium_sp_accc05744_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobacterium_sp_accc05744_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229276"]),
        None,
        Some("."),
        Some("DI53_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium WG36 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229485.AMYV01000001_gene2833";
/// let this_library_node_name2 = "1229485.AMYV01000274_gene4488";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_wg36_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_wg36_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_wg36_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_wg36_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229485"]),
        None,
        Some("."),
        Some("AMYV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium sp. WG21 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229487.AMYW01000001_gene3834";
/// let this_library_node_name2 = "1229487.AMYW01000084_gene3586";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_sp_wg21_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_sp_wg21_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_sp_wg21_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_sp_wg21_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229487"]),
        None,
        Some("."),
        Some("AMYW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blattabacterium sp. BPAA nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229512.460838657";
/// let this_library_node_name2 = "1229512.BPAA_625";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blattabacterium_sp_bpaa_node_name(this_library_node_name1));
/// assert!(is_valid_string_blattabacterium_sp_bpaa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blattabacterium_sp_bpaa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blattabacterium_sp_bpaa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229512"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactococcus garvieae I113 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229517.AMFD01000001_gene577";
/// let this_library_node_name2 = "1229517.AMFD01000049_gene1920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactococcus_garvieae_i113_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactococcus_garvieae_i113_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactococcus_garvieae_i113_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactococcus_garvieae_i113_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229517"]),
        None,
        Some("."),
        Some("AMFD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alkalibacterium sp. AK22 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229520.ADIAL_0001";
/// let this_library_node_name2 = "1229520.ADIAL_2252";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alkalibacterium_sp_ak22_node_name(this_library_node_name1));
/// assert!(is_valid_string_alkalibacterium_sp_ak22_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alkalibacterium_sp_ak22_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alkalibacterium_sp_ak22_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229520"]),
        None,
        Some("."),
        Some("ADIAL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leuconostoc gelidum JB7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229756.C269_00005";
/// let this_library_node_name2 = "1229756.C269_09060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leuconostoc_gelidum_jb7_node_name(this_library_node_name1));
/// assert!(is_valid_string_leuconostoc_gelidum_jb7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leuconostoc_gelidum_jb7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leuconostoc_gelidum_jb7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229756"]),
        None,
        Some("."),
        Some("C269_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leuconostoc carnosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229758.C270_00005";
/// let this_library_node_name2 = "1229758.C270_08051";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leuconostoc_carnosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_leuconostoc_carnosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leuconostoc_carnosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leuconostoc_carnosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229758"]),
        None,
        Some("."),
        Some("C270_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microthrix parvicella nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229780.BN381_100001";
/// let this_library_node_name2 = "1229780.BN381_90114";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microthrix_parvicella_node_name(this_library_node_name1));
/// assert!(is_valid_string_microthrix_parvicella_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microthrix_parvicella_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microthrix_parvicella_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229780"]),
        None,
        Some("."),
        Some("BN381_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacterium casei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229781.C272_00005";
/// let this_library_node_name2 = "1229781.C272_16262";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacterium_casei_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacterium_casei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacterium_casei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacterium_casei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229781"]),
        None,
        Some("."),
        Some("C272_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus massiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229783.C273_00005";
/// let this_library_node_name2 = "1229783.C273_11929";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_massiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_massiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_massiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_massiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229783"]),
        None,
        Some("."),
        Some("C273_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydia avium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229831.M832_00020";
/// let this_library_node_name2 = "1229831.M832_p00080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydia_avium_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydia_avium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydia_avium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydia_avium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229831"]),
        None,
        Some("."),
        Some("M832_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosopumilus sp. AR2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1229909.NSED_00010";
/// let this_library_node_name2 = "1229909.NSED_10025";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosopumilus_sp_ar2_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosopumilus_sp_ar2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosopumilus_sp_ar2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosopumilus_sp_ar2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1229909"]),
        None,
        Some("."),
        Some("NSED_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Moraxella macacae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1230338.MOMA_00005";
/// let this_library_node_name2 = "1230338.MOMA_09341";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_moraxella_macacae_node_name(this_library_node_name1));
/// assert!(is_valid_string_moraxella_macacae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_moraxella_macacae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_moraxella_macacae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1230338"]),
        None,
        Some("."),
        Some("MOMA_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salimicrobium sp. MJ3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1230341.MJ3_00005";
/// let this_library_node_name2 = "1230341.MJ3_13874";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salimicrobium_sp_mj3_node_name(this_library_node_name1));
/// assert!(is_valid_string_salimicrobium_sp_mj3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salimicrobium_sp_mj3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salimicrobium_sp_mj3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1230341"]),
        None,
        Some("."),
        Some("MJ3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium tetanomorphum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1230342.CTM_00005";
/// let this_library_node_name2 = "1230342.CTM_27085";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_tetanomorphum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_tetanomorphum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_tetanomorphum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_tetanomorphum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1230342"]),
        None,
        Some("."),
        Some("CTM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella anisa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1230343.CANP01000001_gene1";
/// let this_library_node_name2 = "1230343.CANP01000056_gene3901";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_anisa_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_anisa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_anisa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_anisa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1230343"]),
        None,
        Some("."),
        Some("CANP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloterrigena limicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1230457.C476_00007";
/// let this_library_node_name2 = "1230457.C476_18022";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloterrigena_limicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloterrigena_limicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloterrigena_limicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloterrigena_limicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1230457"]),
        None,
        Some("."),
        Some("C476_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Natronorubrum sulfidifaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1230460.C495_00005";
/// let this_library_node_name2 = "1230460.C495_17362";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_natronorubrum_sulfidifaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_natronorubrum_sulfidifaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_natronorubrum_sulfidifaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_natronorubrum_sulfidifaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1230460"]),
        None,
        Some("."),
        Some("C495_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. DFCI1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1230476.C207_00001";
/// let this_library_node_name2 = "1230476.C207_07164";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_dfci1_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_dfci1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_dfci1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_dfci1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1230476"]),
        None,
        Some("."),
        Some("C207_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenisporosarcina sp. TG14 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1231057.AMGD01000001_gene2398";
/// let this_library_node_name2 = "1231057.AMGD01000130_gene316";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenisporosarcina_sp_tg14_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenisporosarcina_sp_tg14_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenisporosarcina_sp_tg14_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenisporosarcina_sp_tg14_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1231057"]),
        None,
        Some("."),
        Some("AMGD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitratireductor aquibiodomus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1231185.BAMP01000001_gene4199";
/// let this_library_node_name2 = "1231185.BAMP01000207_gene3506";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitratireductor_aquibiodomus_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitratireductor_aquibiodomus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitratireductor_aquibiodomus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitratireductor_aquibiodomus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1231185"]),
        None,
        Some("."),
        Some("BAMP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitratireductor indicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1231190.NA8A_00005";
/// let this_library_node_name2 = "1231190.NA8A_24251";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitratireductor_indicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitratireductor_indicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitratireductor_indicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitratireductor_indicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1231190"]),
        None,
        Some("."),
        Some("NA8A_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermotoga sp. Mc24 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1231241.Mc24_00005";
/// let this_library_node_name2 = "1231241.Mc24_09339";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermotoga_sp_mc24_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermotoga_sp_mc24_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermotoga_sp_mc24_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermotoga_sp_mc24_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1231241"]),
        None,
        Some("."),
        Some("Mc24_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus shenzhenensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1231336.L248_0005";
/// let this_library_node_name2 = "1231336.L248_3188";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_shenzhenensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_shenzhenensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_shenzhenensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_shenzhenensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1231336"]),
        None,
        Some("."),
        Some("L248_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactococcus garvieae DCC43 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1231377.C426_00001";
/// let this_library_node_name2 = "1231377.C426_2276";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactococcus_garvieae_dcc43_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactococcus_garvieae_dcc43_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactococcus_garvieae_dcc43_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactococcus_garvieae_dcc43_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1231377"]),
        None,
        Some("."),
        Some("C426_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pusillimonas noertemannii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1231391.AMZF01000001_gene2845";
/// let this_library_node_name2 = "1231391.AMZF01000121_gene3474";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pusillimonas_noertemannii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pusillimonas_noertemannii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pusillimonas_noertemannii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pusillimonas_noertemannii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1231391"]),
        None,
        Some("."),
        Some("AMZF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceaniovalibus guishaninsula nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1231392.OCGS_0001";
/// let this_library_node_name2 = "1231392.OCGS_2840";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceaniovalibus_guishaninsula_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceaniovalibus_guishaninsula_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceaniovalibus_guishaninsula_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceaniovalibus_guishaninsula_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1231392"]),
        None,
        Some("."),
        Some("OCGS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cardinium endosymbiont cEper1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1231626.CAHE_0001";
/// let this_library_node_name2 = "1231626.CAHE_0846";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cardinium_endosymbiont_ceper1_node_name(this_library_node_name1));
/// assert!(is_valid_string_cardinium_endosymbiont_ceper1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cardinium_endosymbiont_ceper1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cardinium_endosymbiont_ceper1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1231626"]),
        None,
        Some("."),
        Some("CAHE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfuromonas sp. TF nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232410.KI421412_gene1";
/// let this_library_node_name2 = "1232410.KI421428_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfuromonas_sp_tf_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfuromonas_sp_tf_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfuromonas_sp_tf_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfuromonas_sp_tf_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232410"]),
        None,
        Some("."),
        Some("KI4214"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium sp. GD7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232427.CAVS020000001_gene802";
/// let this_library_node_name2 = "1232427.CAVS020000050_gene1324";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_sp_gd7_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_sp_gd7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_sp_gd7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_sp_gd7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232427"]),
        None,
        Some("."),
        Some("CAVS0200000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Megasphaera sp. NP3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232428.CAVO010000001_gene2348";
/// let this_library_node_name2 = "1232428.CAVO010000141_gene185";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_megasphaera_sp_np3_node_name(this_library_node_name1));
/// assert!(is_valid_string_megasphaera_sp_np3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_megasphaera_sp_np3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_megasphaera_sp_np3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232428"]),
        None,
        Some("."),
        Some("CAVO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nesterenkonia sp. NP1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232429.CBLL010000001_gene2186";
/// let this_library_node_name2 = "1232429.CBLL010000175_gene707";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nesterenkonia_sp_np1_node_name(this_library_node_name1));
/// assert!(is_valid_string_nesterenkonia_sp_np1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nesterenkonia_sp_np1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nesterenkonia_sp_np1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232429"]),
        None,
        Some("."),
        Some("CBLL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nosocomiicoccus sp. NP2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232430.CAVG010000001_gene1";
/// let this_library_node_name2 = "1232430.CAVG010000154_gene1617";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nosocomiicoccus_sp_np2_node_name(this_library_node_name1));
/// assert!(is_valid_string_nosocomiicoccus_sp_np2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nosocomiicoccus_sp_np2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nosocomiicoccus_sp_np2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232430"]),
        None,
        Some("."),
        Some("CAVG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coriobacteriaceae bacterium GD5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232436.CAPF01000001_gene234";
/// let this_library_node_name2 = "1232436.CAPF01000118_gene1015";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coriobacteriaceae_bacterium_gd5_node_name(this_library_node_name1));
/// assert!(is_valid_string_coriobacteriaceae_bacterium_gd5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coriobacteriaceae_bacterium_gd5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coriobacteriaceae_bacterium_gd5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232436"]),
        None,
        Some("."),
        Some("CAPF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfobacula sp. TS nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232437.KL661953_gene2310";
/// let this_library_node_name2 = "1232437.KL662077_gene1961";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfobacula_sp_ts_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfobacula_sp_ts_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfobacula_sp_ts_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfobacula_sp_ts_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232437"]),
        None,
        Some("."),
        Some("KL66"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium VE20213 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232443.BAIA02000001_gene691";
/// let this_library_node_name2 = "1232443.BAIA02000193_gene1209";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_ve20213_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_ve20213_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_ve20213_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_ve20213_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232443"]),
        None,
        Some("."),
        Some("BAIA02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium VE20218 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232446.BAIE02000001_gene1114";
/// let this_library_node_name2 = "1232446.BAIE02000103_gene1164";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_ve20218_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_ve20218_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_ve20218_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_ve20218_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232446"]),
        None,
        Some("."),
        Some("BAIE02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium VE20209 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232447.BAHW02000001_gene1";
/// let this_library_node_name2 = "1232447.BAHW02000078_gene3441";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_ve20209_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_ve20209_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_ve20209_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_ve20209_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232447"]),
        None,
        Some("."),
        Some("BAHW020000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium VE20208 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232449.BAHV02000001_gene256";
/// let this_library_node_name2 = "1232449.BAHV02000037_gene1412";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_ve20208_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_ve20208_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_ve20208_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_ve20208_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232449"]),
        None,
        Some("."),
        Some("BAHV020000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium VE20214 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232452.BAIB02000001_gene1";
/// let this_library_node_name2 = "1232452.BAIB02000031_gene2984";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_ve20214_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_ve20214_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_ve20214_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_ve20214_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232452"]),
        None,
        Some("."),
        Some("BAIB020000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium VE20221 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232453.BAIF02000001_gene1374";
/// let this_library_node_name2 = "1232453.BAIF02000143_gene505";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_ve20221_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_ve20221_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_ve20221_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_ve20221_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232453"]),
        None,
        Some("."),
        Some("BAIF02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus sciuri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232666.JANE01000001_gene167";
/// let this_library_node_name2 = "1232666.JANE01000107_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_sciuri_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_sciuri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_sciuri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_sciuri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232666"]),
        None,
        Some("."),
        Some("JANE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacterium sp. AK27 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1232683.ADIMK_0001";
/// let this_library_node_name2 = "1232683.ADIMK_4210";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacterium_sp_ak27_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacterium_sp_ak27_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacterium_sp_ak27_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacterium_sp_ak27_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1232683"]),
        None,
        Some("."),
        Some("ADIMK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium sp. JM1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1233950.IW22_00010";
/// let this_library_node_name2 = "1233950.IW22_24450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_sp_jm1_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_sp_jm1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_sp_jm1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_sp_jm1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1233950"]),
        None,
        Some("."),
        Some("IW22_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Epilithonimonas sp. FH1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1233951.IO90_00010";
/// let this_library_node_name2 = "1233951.IO90_19110";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_epilithonimonas_sp_fh1_node_name(this_library_node_name1));
/// assert!(is_valid_string_epilithonimonas_sp_fh1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_epilithonimonas_sp_fh1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_epilithonimonas_sp_fh1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1233951"]),
        None,
        Some("."),
        Some("IO90_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dyella ginsengisoli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1234364.AMSF01000001_gene2349";
/// let this_library_node_name2 = "1234364.AMSF01000099_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dyella_ginsengisoli_node_name(this_library_node_name1));
/// assert!(is_valid_string_dyella_ginsengisoli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dyella_ginsengisoli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dyella_ginsengisoli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1234364"]),
        None,
        Some("."),
        Some("AMSF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Catellicoccus marimammalium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1234409.C683_0003";
/// let this_library_node_name2 = "1234409.C683_1250";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_catellicoccus_marimammalium_node_name(this_library_node_name1));
/// assert!(is_valid_string_catellicoccus_marimammalium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_catellicoccus_marimammalium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_catellicoccus_marimammalium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1234409"]),
        None,
        Some("."),
        Some("C683_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus sp. E463 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1234593.ANBY01000001_gene2041";
/// let this_library_node_name2 = "1234593.ANBY01000115_gene2055";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_sp_e463_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_sp_e463_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_sp_e463_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_sp_e463_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1234593"]),
        None,
        Some("."),
        Some("ANBY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING alpha proteobacterium JLT2015 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1234595.C725_0001";
/// let this_library_node_name2 = "1234595.C725_3058";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alpha_proteobacterium_jlt2015_node_name(this_library_node_name1));
/// assert!(is_valid_string_alpha_proteobacterium_jlt2015_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alpha_proteobacterium_jlt2015_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alpha_proteobacterium_jlt2015_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1234595"]),
        None,
        Some("."),
        Some("C725_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacillus caldoxylosilyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1234664.AMRO01000001_gene2282";
/// let this_library_node_name2 = "1234664.AMRO01000081_gene1162";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacillus_caldoxylosilyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacillus_caldoxylosilyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacillus_caldoxylosilyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacillus_caldoxylosilyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1234664"]),
        None,
        Some("."),
        Some("AMRO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carnobacterium maltaromaticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1234679.BN424_1";
/// let this_library_node_name2 = "1234679.BN424_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carnobacterium_maltaromaticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_carnobacterium_maltaromaticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carnobacterium_maltaromaticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carnobacterium_maltaromaticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1234679"]),
        None,
        Some("."),
        Some("BN424_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bhargavaea cecembensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235279.C772_00001";
/// let this_library_node_name2 = "1235279.C772_03230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bhargavaea_cecembensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bhargavaea_cecembensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bhargavaea_cecembensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bhargavaea_cecembensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235279"]),
        None,
        Some("."),
        Some("C772_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ralstonia sp. AU1208 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235457.C404_00005";
/// let this_library_node_name2 = "1235457.C404_29425";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ralstonia_sp_au1208_node_name(this_library_node_name1));
/// assert!(is_valid_string_ralstonia_sp_au1208_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ralstonia_sp_au1208_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ralstonia_sp_au1208_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235457"]),
        None,
        Some("."),
        Some("C404_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinicoccus carnicancri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235755.ANAM01000001_gene100";
/// let this_library_node_name2 = "1235755.ANAM01000012_gene2065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinicoccus_carnicancri_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinicoccus_carnicancri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinicoccus_carnicancri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinicoccus_carnicancri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235755"]),
        None,
        Some("."),
        Some("ANAM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides massiliensis dnLKV3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235788.C802_00001";
/// let this_library_node_name2 = "1235788.C802_04652";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_massiliensis_dnlkv3_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_massiliensis_dnlkv3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_massiliensis_dnlkv3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_massiliensis_dnlkv3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235788"]),
        None,
        Some("."),
        Some("C802_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium sp. 142 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235790.C805_00008";
/// let this_library_node_name2 = "1235790.C805_03842";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_sp_142_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_sp_142_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_sp_142_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_sp_142_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235790"]),
        None,
        Some("."),
        Some("C805_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium M181 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235792.C808_00001";
/// let this_library_node_name2 = "1235792.C808_05408";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_m181_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_m181_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_m181_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_m181_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235792"]),
        None,
        Some("."),
        Some("C808_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium COE1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235793.C809_00001";
/// let this_library_node_name2 = "1235793.C809_04740";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_coe1_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_coe1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_coe1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_coe1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235793"]),
        None,
        Some("."),
        Some("C809_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterorhabdus caecimuris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235794.C811_00001";
/// let this_library_node_name2 = "1235794.C811_02513";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterorhabdus_caecimuris_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterorhabdus_caecimuris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterorhabdus_caecimuris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterorhabdus_caecimuris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235794"]),
        None,
        Some("."),
        Some("C811_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Firmicutes bacterium M102 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235796.C815_00001";
/// let this_library_node_name2 = "1235796.C815_02342";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_firmicutes_bacterium_m102_node_name(this_library_node_name1));
/// assert!(is_valid_string_firmicutes_bacterium_m102_node_name(this_library_node_name2));
/// assert!(!is_valid_string_firmicutes_bacterium_m102_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_firmicutes_bacterium_m102_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235796"]),
        None,
        Some("."),
        Some("C815_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oscillibacter sp. 13 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235797.C816_00001";
/// let this_library_node_name2 = "1235797.C816_04317";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oscillibacter_sp_13_node_name(this_library_node_name1));
/// assert!(is_valid_string_oscillibacter_sp_13_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oscillibacter_sp_13_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oscillibacter_sp_13_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235797"]),
        None,
        Some("."),
        Some("C816_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dorea sp. 52 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235798.C817_00001";
/// let this_library_node_name2 = "1235798.C817_05961";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dorea_sp_52_node_name(this_library_node_name1));
/// assert!(is_valid_string_dorea_sp_52_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dorea_sp_52_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dorea_sp_52_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235798"]),
        None,
        Some("."),
        Some("C817_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium 32 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235799.C818_00001";
/// let this_library_node_name2 = "1235799.C818_04273";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_32_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_32_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_32_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_32_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235799"]),
        None,
        Some("."),
        Some("C818_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium 101 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235800.C819_00001";
/// let this_library_node_name2 = "1235800.C819_04378";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_101_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_101_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_101_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_101_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235800"]),
        None,
        Some("."),
        Some("C819_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus murinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235801.C822_00001";
/// let this_library_node_name2 = "1235801.C822_02174";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_murinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_murinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_murinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_murinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235801"]),
        None,
        Some("."),
        Some("C822_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium plexicaudatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235802.C823_00001";
/// let this_library_node_name2 = "1235802.C823_06290";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_plexicaudatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_plexicaudatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_plexicaudatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_plexicaudatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235802"]),
        None,
        Some("."),
        Some("C823_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parabacteroides sp. ASF519 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235803.C825_00001";
/// let this_library_node_name2 = "1235803.C825_05536";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parabacteroides_sp_asf519_node_name(this_library_node_name1));
/// assert!(is_valid_string_parabacteroides_sp_asf519_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parabacteroides_sp_asf519_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parabacteroides_sp_asf519_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235803"]),
        None,
        Some("."),
        Some("C825_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella disiens JCM6334 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235811.HMPREF0653_00001";
/// let this_library_node_name2 = "1235811.HMPREF0653_02856";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_disiens_jcm6334_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_disiens_jcm6334_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_disiens_jcm6334_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_disiens_jcm6334_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235811"]),
        None,
        Some("."),
        Some("HMPREF0653_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides pyogenes JCM10003 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235813.JCM10003_1";
/// let this_library_node_name2 = "1235813.JCM10003_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_pyogenes_jcm10003_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_pyogenes_jcm10003_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_pyogenes_jcm10003_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_pyogenes_jcm10003_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235813"]),
        None,
        Some("."),
        Some("JCM10003_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella enoeca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235815.BAIX01000001_gene1";
/// let this_library_node_name2 = "1235815.BAIX01000117_gene2635";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_enoeca_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_enoeca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_enoeca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_enoeca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235815"]),
        None,
        Some("."),
        Some("BAIX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerotruncus sp. G3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235835.C814_00001";
/// let this_library_node_name2 = "1235835.C814_03519";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerotruncus_sp_g3_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerotruncus_sp_g3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerotruncus_sp_g3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerotruncus_sp_g3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235835"]),
        None,
        Some("."),
        Some("C814_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halyomorpha halys nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1235990.HHS_00010";
/// let this_library_node_name2 = "1235990.HHS_08250";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halyomorpha_halys_node_name(this_library_node_name1));
/// assert!(is_valid_string_halyomorpha_halys_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halyomorpha_halys_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halyomorpha_halys_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1235990"]),
        None,
        Some("."),
        Some("HHS_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella pleuritidis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236494.BAJN01000001_gene1";
/// let this_library_node_name2 = "1236494.BAJN01000048_gene2266";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_pleuritidis_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_pleuritidis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_pleuritidis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_pleuritidis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236494"]),
        None,
        Some("."),
        Some("BAJN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella oulorum JCM14966 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236497.BAJQ01000001_gene530";
/// let this_library_node_name2 = "1236497.BAJQ01000138_gene222";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_oulorum_jcm14966_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_oulorum_jcm14966_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_oulorum_jcm14966_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_oulorum_jcm14966_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236497"]),
        None,
        Some("."),
        Some("BAJQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetobacter okinawensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236501.BAJU01000001_gene1";
/// let this_library_node_name2 = "1236501.BAJU01000127_gene3375";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetobacter_okinawensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetobacter_okinawensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetobacter_okinawensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetobacter_okinawensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236501"]),
        None,
        Some("."),
        Some("BAJU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella histicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236504.HMPREF2132_00010";
/// let this_library_node_name2 = "1236504.HMPREF2132_13095";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_histicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_histicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_histicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_histicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236504"]),
        None,
        Some("."),
        Some("HMPREF2132_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella aurantiaca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236508.BAKF01000001_gene1";
/// let this_library_node_name2 = "1236508.BAKF01000148_gene2761";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_aurantiaca_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_aurantiaca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_aurantiaca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_aurantiaca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236508"]),
        None,
        Some("."),
        Some("BAKF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides stercorirosoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236514.BAKL01000001_gene1";
/// let this_library_node_name2 = "1236514.BAKL01000201_gene5898";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_stercorirosoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_stercorirosoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_stercorirosoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_stercorirosoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236514"]),
        None,
        Some("."),
        Some("BAKL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella fusca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236517.BAKO01000001_gene2580";
/// let this_library_node_name2 = "1236517.BAKO01000116_gene202";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_fusca_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_fusca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_fusca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_fusca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236517"]),
        None,
        Some("."),
        Some("BAKO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella scopos nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236518.BAKP01000001_gene1";
/// let this_library_node_name2 = "1236518.BAKP01000113_gene2770";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_scopos_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_scopos_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_scopos_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_scopos_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236518"]),
        None,
        Some("."),
        Some("BAKP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella haliotis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236541.BALL01000001_gene1";
/// let this_library_node_name2 = "1236541.BALL01000125_gene5135";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_haliotis_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_haliotis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_haliotis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_haliotis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236541"]),
        None,
        Some("."),
        Some("BALL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella marina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236542.BALM01000001_gene1";
/// let this_library_node_name2 = "1236542.BALM01000073_gene2058";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_marina_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_marina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_marina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_marina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236542"]),
        None,
        Some("."),
        Some("BALM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methanomethylophilus alvus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236689.MMALV_00010";
/// let this_library_node_name2 = "1236689.MMALV_16960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methanomethylophilus_alvus_node_name(this_library_node_name1));
/// assert!(is_valid_string_methanomethylophilus_alvus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methanomethylophilus_alvus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methanomethylophilus_alvus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236689"]),
        None,
        Some("."),
        Some("MMALV_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardiopsis baichengensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236902.ANAS01000001_gene1794";
/// let this_library_node_name2 = "1236902.ANAS01000071_gene3014";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardiopsis_baichengensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardiopsis_baichengensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardiopsis_baichengensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardiopsis_baichengensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236902"]),
        None,
        Some("."),
        Some("ANAS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Wolbachia sp. Dsi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236908.wNo_00010";
/// let this_library_node_name2 = "1236908.wNo_11390";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_wolbachia_sp_dsi_node_name(this_library_node_name1));
/// assert!(is_valid_string_wolbachia_sp_dsi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_wolbachia_sp_dsi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_wolbachia_sp_dsi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236908"]),
        None,
        Some("."),
        Some("wNo_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylobacillus glycogenes nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236959.BAMT01000001_gene1000";
/// let this_library_node_name2 = "1236959.BAMT01000028_gene18";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylobacillus_glycogenes_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylobacillus_glycogenes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylobacillus_glycogenes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylobacillus_glycogenes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236959"]),
        None,
        Some("."),
        Some("BAMT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus akibai nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236973.JCM9157_1";
/// let this_library_node_name2 = "1236973.JCM9157_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_akibai_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_akibai_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_akibai_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_akibai_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236973"]),
        None,
        Some("."),
        Some("JCM9157_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus pini nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1236976.JCM16418_1";
/// let this_library_node_name2 = "1236976.JCM16418_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_pini_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_pini_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_pini_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_pini_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1236976"]),
        None,
        Some("."),
        Some("JCM16418_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fulvivirga imtechensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1237149.C900_00001";
/// let this_library_node_name2 = "1237149.C900_05958";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fulvivirga_imtechensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_fulvivirga_imtechensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fulvivirga_imtechensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fulvivirga_imtechensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1237149"]),
        None,
        Some("."),
        Some("C900_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardiopsis ganjiahuensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1237500.ANBA01000001_gene5029";
/// let this_library_node_name2 = "1237500.ANBA01000054_gene2715";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardiopsis_ganjiahuensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardiopsis_ganjiahuensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardiopsis_ganjiahuensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardiopsis_ganjiahuensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1237500"]),
        None,
        Some("."),
        Some("ANBA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caenispirillum salinarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1238182.C882_0001";
/// let this_library_node_name2 = "1238182.C882_4585";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caenispirillum_salinarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_caenispirillum_salinarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caenispirillum_salinarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caenispirillum_salinarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1238182"]),
        None,
        Some("."),
        Some("C882_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanobacillus kimchii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1238184.CM001792_gene1";
/// let this_library_node_name2 = "1238184.CM001792_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanobacillus_kimchii_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanobacillus_kimchii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanobacillus_kimchii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanobacillus_kimchii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1238184"]),
        None,
        Some("."),
        Some("CM001792_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leucobacter salsicius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1238186.AOCN01000001_gene162";
/// let this_library_node_name2 = "1238186.AOCN01000028_gene1813";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leucobacter_salsicius_node_name(this_library_node_name1));
/// assert!(is_valid_string_leucobacter_salsicius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leucobacter_salsicius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leucobacter_salsicius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1238186"]),
        None,
        Some("."),
        Some("AOCN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas jeotgali nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1238190.AMQY01000001_gene598";
/// let this_library_node_name2 = "1238190.AMQY01000026_gene121";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_jeotgali_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_jeotgali_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_jeotgali_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_jeotgali_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1238190"]),
        None,
        Some("."),
        Some("AMQY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydia psittaci 10139811 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1238237.CP10139811_0001";
/// let this_library_node_name2 = "1238237.CP10139811_1698";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydia_psittaci_10139811_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydia_psittaci_10139811_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydia_psittaci_10139811_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydia_psittaci_10139811_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1238237"]),
        None,
        Some("."),
        Some("CP10139811_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloquadratum walsbyi J07HQW2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1238425.J07HQW2_00001";
/// let this_library_node_name2 = "1238425.J07HQW2_03907";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloquadratum_walsbyi_j07hqw2_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloquadratum_walsbyi_j07hqw2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloquadratum_walsbyi_j07hqw2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloquadratum_walsbyi_j07hqw2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1238425"]),
        None,
        Some("."),
        Some("J07HQW2_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio nigripulchritudo nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1238450.VIBNISOn1_1000001";
/// let this_library_node_name2 = "1238450.VIBNISOn1_p0232";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_nigripulchritudo_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_nigripulchritudo_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_nigripulchritudo_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_nigripulchritudo_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1238450"]),
        None,
        Some("."),
        Some("VIBNISOn1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dokdonia sp. PRO95 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1239415.CM001837_gene1";
/// let this_library_node_name2 = "1239415.CM001837_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dokdonia_sp_pro95_node_name(this_library_node_name1));
/// assert!(is_valid_string_dokdonia_sp_pro95_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dokdonia_sp_pro95_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dokdonia_sp_pro95_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1239415"]),
        None,
        Some("."),
        Some("CM001837_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mariniradius saccharolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1239962.C943_00001";
/// let this_library_node_name2 = "1239962.C943_04647";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mariniradius_saccharolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_mariniradius_saccharolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mariniradius_saccharolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mariniradius_saccharolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1239962"]),
        None,
        Some("."),
        Some("C943_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus ruber nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1240349.ANGC01000001_gene2404";
/// let this_library_node_name2 = "1240349.ANGC01000156_gene4939";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_ruber_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_ruber_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_ruber_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_ruber_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1240349"]),
        None,
        Some("."),
        Some("ANGC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas putida MTCC5279 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1240350.AMZE01000001_gene2827";
/// let this_library_node_name2 = "1240350.AMZE01000167_gene2369";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_putida_mtcc5279_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_putida_mtcc5279_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_putida_mtcc5279_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_putida_mtcc5279_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1240350"]),
        None,
        Some("."),
        Some("AMZE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cystobacter fuscus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1242864.D187_000001";
/// let this_library_node_name2 = "1242864.D187_010539";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cystobacter_fuscus_node_name(this_library_node_name1));
/// assert!(is_valid_string_cystobacter_fuscus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cystobacter_fuscus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cystobacter_fuscus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1242864"]),
        None,
        Some("."),
        Some("D187_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter concisus ATCC51562 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1242969.ATCC51562_1";
/// let this_library_node_name2 = "1242969.ATCC51562_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_concisus_atcc51562_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_concisus_atcc51562_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_concisus_atcc51562_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_concisus_atcc51562_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1242969"]),
        None,
        Some("."),
        Some("ATCC51562_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. G2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1243664.CAVL020000001_gene4728";
/// let this_library_node_name2 = "1243664.CAVL020000066_gene1073";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_g2_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_g2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_g2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_g2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1243664"]),
        None,
        Some("."),
        Some("CAVL0200000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter showae CSUNSWCD nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1244083.CSUNSWCD_1";
/// let this_library_node_name2 = "1244083.CSUNSWCD_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_showae_csunswcd_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_showae_csunswcd_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_showae_csunswcd_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_showae_csunswcd_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1244083"]),
        None,
        Some("."),
        Some("CSUNSWCD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter fetus testudinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1244528.CFT03427_0001";
/// let this_library_node_name2 = "1244528.CFT03427_1761";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_fetus_testudinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_fetus_testudinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_fetus_testudinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_fetus_testudinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1244528"]),
        None,
        Some("."),
        Some("CFT03427_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter sp. 1485E nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1244531.CIG1485E_0001";
/// let this_library_node_name2 = "1244531.CIG1485E_a0111";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_sp_1485e_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_sp_1485e_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_sp_1485e_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_sp_1485e_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1244531"]),
        None,
        Some("."),
        Some("CIG1485E_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Magnetospirillum sp. SO1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1244869.H261_00005";
/// let this_library_node_name2 = "1244869.H261_23482";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_magnetospirillum_sp_so1_node_name(this_library_node_name1));
/// assert!(is_valid_string_magnetospirillum_sp_so1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_magnetospirillum_sp_so1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_magnetospirillum_sp_so1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1244869"]),
        None,
        Some("."),
        Some("H261_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium oligotrophicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1245469.S58_00010";
/// let this_library_node_name2 = "1245469.S58_72850";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_oligotrophicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_oligotrophicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_oligotrophicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_oligotrophicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1245469"]),
        None,
        Some("."),
        Some("S58_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas resinovorans NBRC106553 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1245471.PCA10_00010";
/// let this_library_node_name2 = "1245471.PCA10_p2230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_resinovorans_nbrc106553_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_resinovorans_nbrc106553_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_resinovorans_nbrc106553_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_resinovorans_nbrc106553_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1245471"]),
        None,
        Some("."),
        Some("PCA10_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardiopsis prasina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1245475.ANAE01000001_gene1494";
/// let this_library_node_name2 = "1245475.ANAE01000240_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardiopsis_prasina_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardiopsis_prasina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardiopsis_prasina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardiopsis_prasina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1245475"]),
        None,
        Some("."),
        Some("ANAE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardiopsis kunsanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1246445.ANAY01000001_gene344";
/// let this_library_node_name2 = "1246445.ANAY01000097_gene4338";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardiopsis_kunsanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardiopsis_kunsanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardiopsis_kunsanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardiopsis_kunsanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1246445"]),
        None,
        Some("."),
        Some("ANAY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardiopsis valliformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1246448.ANAZ01000001_gene4074";
/// let this_library_node_name2 = "1246448.ANAZ01000088_gene911";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardiopsis_valliformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardiopsis_valliformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardiopsis_valliformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardiopsis_valliformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1246448"]),
        None,
        Some("."),
        Some("ANAZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. 2MFCol31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1246459.KB898353_gene107";
/// let this_library_node_name2 = "1246459.KB898396_gene5154";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_2mfcol31_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_2mfcol31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_2mfcol31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_2mfcol31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1246459"]),
        None,
        Some("."),
        Some("KB8983"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardiopsis xinjiangensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1246474.ANBE01000001_gene3086";
/// let this_library_node_name2 = "1246474.ANBE01000090_gene3756";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardiopsis_xinjiangensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardiopsis_xinjiangensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardiopsis_xinjiangensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardiopsis_xinjiangensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1246474"]),
        None,
        Some("."),
        Some("ANBE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halobacillus sp. BAB2008 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1246484.D479_00005";
/// let this_library_node_name2 = "1246484.D479_20322";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halobacillus_sp_bab2008_node_name(this_library_node_name1));
/// assert!(is_valid_string_halobacillus_sp_bab2008_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halobacillus_sp_bab2008_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halobacillus_sp_bab2008_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1246484"]),
        None,
        Some("."),
        Some("D479_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus lehensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1246626.BleG1_0002";
/// let this_library_node_name2 = "1246626.BleG1_4104";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_lehensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_lehensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_lehensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_lehensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1246626"]),
        None,
        Some("."),
        Some("BleG1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma cynos nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1246955.MCYN_0001";
/// let this_library_node_name2 = "1246955.MCYN_0883";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_cynos_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_cynos_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_cynos_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_cynos_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1246955"]),
        None,
        Some("."),
        Some("MCYN_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinoplanes friuliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1246995.AFR_00005";
/// let this_library_node_name2 = "1246995.AFR_43000";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinoplanes_friuliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinoplanes_friuliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinoplanes_friuliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinoplanes_friuliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1246995"]),
        None,
        Some("."),
        Some("AFR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arsenophonus endosymbiont nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1247024.JRLH01000001_gene1000";
/// let this_library_node_name2 = "1247024.JRLH01000021_gene49";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arsenophonus_endosymbiont_node_name(this_library_node_name1));
/// assert!(is_valid_string_arsenophonus_endosymbiont_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arsenophonus_endosymbiont_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arsenophonus_endosymbiont_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1247024"]),
        None,
        Some("."),
        Some("JRLH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bordetella holmesii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1247649.D560_0005";
/// let this_library_node_name2 = "1247649.D560_3978";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bordetella_holmesii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bordetella_holmesii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bordetella_holmesii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bordetella_holmesii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1247649"]),
        None,
        Some("."),
        Some("D560_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Advenella mimigardefordensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1247726.MIM_24p00010";
/// let this_library_node_name2 = "1247726.MIM_c41170";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_advenella_mimigardefordensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_advenella_mimigardefordensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_advenella_mimigardefordensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_advenella_mimigardefordensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1247726"]),
        None,
        Some("."),
        Some("MIM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Parvularcula oceani nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1247963.JPHU01000001_gene1719";
/// let this_library_node_name2 = "1247963.JPHU01000037_gene2775";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_parvularcula_oceani_node_name(this_library_node_name1));
/// assert!(is_valid_string_parvularcula_oceani_node_name(this_library_node_name2));
/// assert!(!is_valid_string_parvularcula_oceani_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_parvularcula_oceani_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1247963"]),
        None,
        Some("."),
        Some("JPHU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photobacterium leiognathi lrivu41 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1248232.BANQ01000001_gene1900";
/// let this_library_node_name2 = "1248232.BANQ01000184_gene194";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photobacterium_leiognathi_lrivu41_node_name(this_library_node_name1));
/// assert!(is_valid_string_photobacterium_leiognathi_lrivu41_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photobacterium_leiognathi_lrivu41_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photobacterium_leiognathi_lrivu41_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1248232"]),
        None,
        Some("."),
        Some("BANQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blastomonas sp. AAP53 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1248760.ANFZ01000001_gene95";
/// let this_library_node_name2 = "1248760.ANFZ01000028_gene11";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blastomonas_sp_aap53_node_name(this_library_node_name1));
/// assert!(is_valid_string_blastomonas_sp_aap53_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blastomonas_sp_aap53_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blastomonas_sp_aap53_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1248760"]),
        None,
        Some("."),
        Some("ANFZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sandarakinorhabdus sp. AAP62 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1248916.ANFY01000002_gene1290";
/// let this_library_node_name2 = "1248916.ANFY01000022_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sandarakinorhabdus_sp_aap62_node_name(this_library_node_name1));
/// assert!(is_valid_string_sandarakinorhabdus_sp_aap62_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sandarakinorhabdus_sp_aap62_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sandarakinorhabdus_sp_aap62_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1248916"]),
        None,
        Some("."),
        Some("ANFY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyrobacter sp. AAP82 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1248917.ANFX01000001_gene1402";
/// let this_library_node_name2 = "1248917.ANFX01000052_gene568";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyrobacter_sp_aap82_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyrobacter_sp_aap82_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyrobacter_sp_aap82_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyrobacter_sp_aap82_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1248917"]),
        None,
        Some("."),
        Some("ANFX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfuricurvum sp. RIFRC1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1249480.B649_00005";
/// let this_library_node_name2 = "1249480.B649_11924";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfuricurvum_sp_rifrc1_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfuricurvum_sp_rifrc1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfuricurvum_sp_rifrc1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfuricurvum_sp_rifrc1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1249480"]),
        None,
        Some("."),
        Some("B649_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thiorhodococcus sp. AK35 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1249627.D779_0001";
/// let this_library_node_name2 = "1249627.D779_4241";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thiorhodococcus_sp_ak35_node_name(this_library_node_name1));
/// assert!(is_valid_string_thiorhodococcus_sp_ak35_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thiorhodococcus_sp_ak35_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thiorhodococcus_sp_ak35_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1249627"]),
        None,
        Some("."),
        Some("D779_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia marcescens FGI94 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1249634.D781_0001";
/// let this_library_node_name2 = "1249634.D781_4609";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_marcescens_fgi94_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_marcescens_fgi94_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_marcescens_fgi94_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_marcescens_fgi94_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1249634"]),
        None,
        Some("."),
        Some("D781_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gillisia sp. HelI29 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1249975.JQLP01000001_gene2808";
/// let this_library_node_name2 = "1249975.JQLP01000009_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gillisia_sp_heli29_node_name(this_library_node_name1));
/// assert!(is_valid_string_gillisia_sp_heli29_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gillisia_sp_heli29_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gillisia_sp_heli29_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1249975"]),
        None,
        Some("."),
        Some("JQLP0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Maribacter sp. HelI7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1249997.JHZW01000001_gene3925";
/// let this_library_node_name2 = "1249997.JHZW01000003_gene3924";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_maribacter_sp_heli7_node_name(this_library_node_name1));
/// assert!(is_valid_string_maribacter_sp_heli7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_maribacter_sp_heli7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_maribacter_sp_heli7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1249997"]),
        None,
        Some("."),
        Some("JHZW0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polaribacter sp. Hel185 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1250005.PHEL85_0006";
/// let this_library_node_name2 = "1250005.PHEL85_3486";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polaribacter_sp_hel185_node_name(this_library_node_name1));
/// assert!(is_valid_string_polaribacter_sp_hel185_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polaribacter_sp_hel185_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polaribacter_sp_hel185_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1250005"]),
        None,
        Some("."),
        Some("PHEL85_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polaribacter sp. HelI88 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1250006.JHZZ01000001_gene1";
/// let this_library_node_name2 = "1250006.JHZZ01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polaribacter_sp_heli88_node_name(this_library_node_name1));
/// assert!(is_valid_string_polaribacter_sp_heli88_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polaribacter_sp_heli88_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polaribacter_sp_heli88_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1250006"]),
        None,
        Some("."),
        Some("JHZZ01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Muricauda sp. MAR201075 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1250232.JQNJ01000001_gene1";
/// let this_library_node_name2 = "1250232.JQNJ01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_muricauda_sp_mar201075_node_name(this_library_node_name1));
/// assert!(is_valid_string_muricauda_sp_mar201075_node_name(this_library_node_name2));
/// assert!(!is_valid_string_muricauda_sp_mar201075_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_muricauda_sp_mar201075_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1250232"]),
        None,
        Some("."),
        Some("JQNJ01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salegentibacter sp. HelI6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1250278.JQNQ01000001_gene1";
/// let this_library_node_name2 = "1250278.JQNQ01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salegentibacter_sp_heli6_node_name(this_library_node_name1));
/// assert!(is_valid_string_salegentibacter_sp_heli6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salegentibacter_sp_heli6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salegentibacter_sp_heli6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1250278"]),
        None,
        Some("."),
        Some("JQNQ01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sorangium cellulosum So01572 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1254432.SCE1572_00005";
/// let this_library_node_name2 = "1254432.SCE1572_52720";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sorangium_cellulosum_so01572_node_name(this_library_node_name1));
/// assert!(is_valid_string_sorangium_cellulosum_so01572_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sorangium_cellulosum_so01572_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sorangium_cellulosum_so01572_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1254432"]),
        None,
        Some("."),
        Some("SCE1572_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio nitratireducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1255043.TVNIR_0001";
/// let this_library_node_name2 = "1255043.TVNIR_3869";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_nitratireducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_nitratireducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_nitratireducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_nitratireducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1255043"]),
        None,
        Some("."),
        Some("TVNIR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium ramulus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1256908.HMPREF0373_00001";
/// let this_library_node_name2 = "1256908.HMPREF0373_03521";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_ramulus_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_ramulus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_ramulus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_ramulus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1256908"]),
        None,
        Some("."),
        Some("HMPREF0373_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coprothermobacter platensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1259795.ARJK01000001_gene645";
/// let this_library_node_name2 = "1259795.ARJK01000006_gene644";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coprothermobacter_platensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_coprothermobacter_platensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coprothermobacter_platensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coprothermobacter_platensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1259795"]),
        None,
        Some("."),
        Some("ARJK0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiribacter salinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1260251.SPISAL_00005";
/// let this_library_node_name2 = "1260251.SPISAL_08455";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiribacter_salinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiribacter_salinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiribacter_salinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiribacter_salinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1260251"]),
        None,
        Some("."),
        Some("SPISAL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus faecalis 13SDW01 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1260356.D920_00001";
/// let this_library_node_name2 = "1260356.D920_03150";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_faecalis_13sdw01_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_faecalis_13sdw01_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_faecalis_13sdw01_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_faecalis_13sdw01_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1260356"]),
        None,
        Some("."),
        Some("D920_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Liberibacter americanus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1261131.lam_001";
/// let this_library_node_name2 = "1261131.lam_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_liberibacter_americanus_node_name(this_library_node_name1));
/// assert!(is_valid_string_liberibacter_americanus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_liberibacter_americanus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_liberibacter_americanus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1261131"]),
        None,
        Some("."),
        Some("lam_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halarchaeum acidiphilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1261545.MBE-HAL_0001";
/// let this_library_node_name2 = "1261545.MBE-HAL_2708";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halarchaeum_acidiphilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_halarchaeum_acidiphilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halarchaeum_acidiphilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halarchaeum_acidiphilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1261545"]),
        None,
        Some("."),
        Some("MBE-HAL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium pasteurianum DSM525 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1262449.CP6013_0002";
/// let this_library_node_name2 = "1262449.CP6013_4055";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_pasteurianum_dsm525_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_pasteurianum_dsm525_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_pasteurianum_dsm525_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_pasteurianum_dsm525_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1262449"]),
        None,
        Some("."),
        Some("CP6013_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phascolarctobacterium sp. CAG207 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1262914.BN533_00001";
/// let this_library_node_name2 = "1262914.BN533_02229";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phascolarctobacterium_sp_cag207_node_name(this_library_node_name1));
/// assert!(is_valid_string_phascolarctobacterium_sp_cag207_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phascolarctobacterium_sp_cag207_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phascolarctobacterium_sp_cag207_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1262914"]),
        None,
        Some("."),
        Some("BN533_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phascolarctobacterium sp. CAG266 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1262915.BN574_00001";
/// let this_library_node_name2 = "1262915.BN574_01778";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phascolarctobacterium_sp_cag266_node_name(this_library_node_name1));
/// assert!(is_valid_string_phascolarctobacterium_sp_cag266_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phascolarctobacterium_sp_cag266_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phascolarctobacterium_sp_cag266_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1262915"]),
        None,
        Some("."),
        Some("BN574_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bibersteinia trehalosi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1263831.F543_10";
/// let this_library_node_name2 = "1263831.F543_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bibersteinia_trehalosi_node_name(this_library_node_name1));
/// assert!(is_valid_string_bibersteinia_trehalosi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bibersteinia_trehalosi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bibersteinia_trehalosi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1263831"]),
        None,
        Some("."),
        Some("F543_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium asiaticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1265310.CCBD010000001_gene4884";
/// let this_library_node_name2 = "1265310.CCBD010000102_gene4355";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_asiaticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_asiaticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_asiaticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_asiaticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1265310"]),
        None,
        Some("."),
        Some("CCBD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haliea rubra nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1265313.HRUBRA_00001";
/// let this_library_node_name2 = "1265313.HRUBRA_02903";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haliea_rubra_node_name(this_library_node_name1));
/// assert!(is_valid_string_haliea_rubra_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haliea_rubra_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haliea_rubra_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1265313"]),
        None,
        Some("."),
        Some("HRUBRA_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. URMO17WK12I8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1265490.JHVY01000001_gene3456";
/// let this_library_node_name2 = "1265490.JHVY01000053_gene4408";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_urmo17wk12i8_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_urmo17wk12i8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_urmo17wk12i8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_urmo17wk12i8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1265490"]),
        None,
        Some("."),
        Some("JHVY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldimonas manganoxidans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1265502.KB905929_gene2132";
/// let this_library_node_name2 = "1265502.KB906017_gene7";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldimonas_manganoxidans_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldimonas_manganoxidans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldimonas_manganoxidans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldimonas_manganoxidans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1265502"]),
        None,
        Some("."),
        Some("KB90"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Colwellia piezophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1265503.KB905160_gene2360";
/// let this_library_node_name2 = "1265503.KB905197_gene2355";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_colwellia_piezophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_colwellia_piezophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_colwellia_piezophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_colwellia_piezophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1265503"]),
        None,
        Some("."),
        Some("KB9051"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfospira joergensenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1265505.ATUG01000001_gene2832";
/// let this_library_node_name2 = "1265505.ATUG01000006_gene4826";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfospira_joergensenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfospira_joergensenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfospira_joergensenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfospira_joergensenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1265505"]),
        None,
        Some("."),
        Some("ATUG0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Succinimonas amylolytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1265507.KB899636_gene1102";
/// let this_library_node_name2 = "1265507.KB899658_gene665";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_succinimonas_amylolytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_succinimonas_amylolytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_succinimonas_amylolytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_succinimonas_amylolytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1265507"]),
        None,
        Some("."),
        Some("KB8996"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibacter ubique HTCC9022 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1265756.AWZW01000001_gene10";
/// let this_library_node_name2 = "1265756.AWZW01000015_gene1413";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibacter_ubique_htcc9022_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibacter_ubique_htcc9022_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibacter_ubique_htcc9022_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibacter_ubique_htcc9022_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1265756"]),
        None,
        Some("."),
        Some("AWZW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeria weihenstephanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1265845.PWEIH_00005";
/// let this_library_node_name2 = "1265845.PWEIH_17159";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeria_weihenstephanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeria_weihenstephanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeria_weihenstephanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeria_weihenstephanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1265845"]),
        None,
        Some("."),
        Some("PWEIH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carnobacterium sp. WN1359 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1266845.Q783_00005";
/// let this_library_node_name2 = "1266845.Q783_11820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carnobacterium_sp_wn1359_node_name(this_library_node_name1));
/// assert!(is_valid_string_carnobacterium_sp_wn1359_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carnobacterium_sp_wn1359_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carnobacterium_sp_wn1359_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1266845"]),
        None,
        Some("."),
        Some("Q783_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALE6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1266908.AQPB01000001_gene1619";
/// let this_library_node_name2 = "1266908.AQPB01000061_gene1422";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_ale6_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_ale6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_ale6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_ale6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1266908"]),
        None,
        Some("."),
        Some("AQPB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALE19 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1266909.AUAG01000001_gene1373";
/// let this_library_node_name2 = "1266909.AUAG01000069_gene1372";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_ale19_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_ale19_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_ale19_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_ale19_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1266909"]),
        None,
        Some("."),
        Some("AUAG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. AKL19 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1266914.ATUK01000001_gene737";
/// let this_library_node_name2 = "1266914.ATUK01000018_gene736";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_akl19_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_akl19_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_akl19_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_akl19_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1266914"]),
        None,
        Some("."),
        Some("ATUK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosospira briensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1266925.JHVX01000001_gene2435";
/// let this_library_node_name2 = "1266925.JHVX01000031_gene1547";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosospira_briensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosospira_briensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosospira_briensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosospira_briensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1266925"]),
        None,
        Some("."),
        Some("JHVX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus zeaxanthinifaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1266998.ATUJ01000001_gene2500";
/// let this_library_node_name2 = "1266998.ATUJ01000034_gene506";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_zeaxanthinifaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_zeaxanthinifaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_zeaxanthinifaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_zeaxanthinifaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1266998"]),
        None,
        Some("."),
        Some("ATUJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus parabrevis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1267003.KB911365_gene386";
/// let this_library_node_name2 = "1267003.KB911457_gene537";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_parabrevis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_parabrevis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_parabrevis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_parabrevis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1267003"]),
        None,
        Some("."),
        Some("KB911"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomicrobium zavarzinii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1267005.KB911255_gene2369";
/// let this_library_node_name2 = "1267005.KB911269_gene3206";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomicrobium_zavarzinii_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomicrobium_zavarzinii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomicrobium_zavarzinii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomicrobium_zavarzinii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1267005"]),
        None,
        Some("."),
        Some("KB9112"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sediminibacterium sp. C3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1267211.KI669560_gene1";
/// let this_library_node_name2 = "1267211.KI669560_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sediminibacterium_sp_c3_node_name(this_library_node_name1));
/// assert!(is_valid_string_sediminibacterium_sp_c3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sediminibacterium_sp_c3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sediminibacterium_sp_c3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1267211"]),
        None,
        Some("."),
        Some("KI669560_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidobacteriaceae bacterium KBS83 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1267533.KB906733_gene2797";
/// let this_library_node_name2 = "1267533.KB906753_gene5";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidobacteriaceae_bacterium_kbs83_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidobacteriaceae_bacterium_kbs83_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidobacteriaceae_bacterium_kbs83_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidobacteriaceae_bacterium_kbs83_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1267533"]),
        None,
        Some("."),
        Some("KB9067"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidobacteriaceae bacterium KBS89 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1267534.KB906754_gene2542";
/// let this_library_node_name2 = "1267534.KB906766_gene1628";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidobacteriaceae_bacterium_kbs89_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidobacteriaceae_bacterium_kbs89_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidobacteriaceae_bacterium_kbs89_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidobacteriaceae_bacterium_kbs89_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1267534"]),
        None,
        Some("."),
        Some("KB9067"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidobacteriaceae bacterium KBS96 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1267535.KB906767_gene1";
/// let this_library_node_name2 = "1267535.KB906768_gene5538";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidobacteriaceae_bacterium_kbs96_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidobacteriaceae_bacterium_kbs96_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidobacteriaceae_bacterium_kbs96_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidobacteriaceae_bacterium_kbs96_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1267535"]),
        None,
        Some("."),
        Some("KB90676"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anoxybacillus flavithermus TNO09006 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1267580.AF6_0001";
/// let this_library_node_name2 = "1267580.AF6_2761";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anoxybacillus_flavithermus_tno09006_node_name(this_library_node_name1));
/// assert!(is_valid_string_anoxybacillus_flavithermus_tno09006_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anoxybacillus_flavithermus_tno09006_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anoxybacillus_flavithermus_tno09006_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1267580"]),
        None,
        Some("."),
        Some("AF6_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea sp. IMH nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1267600.JFGT01000001_gene2061";
/// let this_library_node_name2 = "1267600.JFGT01000007_gene1871";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_sp_imh_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_sp_imh_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_sp_imh_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_sp_imh_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1267600"]),
        None,
        Some("."),
        Some("JFGT0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. G5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1268068.PG5_00010";
/// let this_library_node_name2 = "1268068.PG5_67690";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_g5_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_g5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_g5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_g5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1268068"]),
        None,
        Some("."),
        Some("PG5_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sabinae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1268072.PSAB_00005";
/// let this_library_node_name2 = "1268072.PSAB_24245";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sabinae_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sabinae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sabinae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sabinae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1268072"]),
        None,
        Some("."),
        Some("PSAB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aeromonas diversa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1268237.G114_00005";
/// let this_library_node_name2 = "1268237.G114_19190";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aeromonas_diversa_node_name(this_library_node_name1));
/// assert!(is_valid_string_aeromonas_diversa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aeromonas_diversa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aeromonas_diversa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1268237"]),
        None,
        Some("."),
        Some("G114_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas luteoviolacea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1268239.PALB_10";
/// let this_library_node_name2 = "1268239.PALB_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_luteoviolacea_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_luteoviolacea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_luteoviolacea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_luteoviolacea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1268239"]),
        None,
        Some("."),
        Some("PALB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides cellulosilyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1268240.ATFI01000001_gene2590";
/// let this_library_node_name2 = "1268240.ATFI01000024_gene176";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_cellulosilyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_cellulosilyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_cellulosilyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_cellulosilyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1268240"]),
        None,
        Some("."),
        Some("ATFI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus sp. AW25M09 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1268303.RHODMAR_0001";
/// let this_library_node_name2 = "1268303.RHODMAR_5122";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_sp_aw25m09_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_sp_aw25m09_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_sp_aw25m09_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_sp_aw25m09_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1268303"]),
        None,
        Some("."),
        Some("RHODMAR_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidovorax sp. MRS7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1268622.524552798";
/// let this_library_node_name2 = "1268622.AVS7_04761";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidovorax_sp_mrs7_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidovorax_sp_mrs7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidovorax_sp_mrs7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidovorax_sp_mrs7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1268622"]),
        None,
        Some("."),
        None,
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella oakridgensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1268635.Loa_00001";
/// let this_library_node_name2 = "1268635.Loa_50p0045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_oakridgensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_oakridgensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_oakridgensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_oakridgensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1268635"]),
        None,
        Some("."),
        Some("Loa_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. ALR1721 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1269813.ATUL01000001_gene1000";
/// let this_library_node_name2 = "1269813.ATUL01000065_gene1241";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_alr1721_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_alr1721_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_alr1721_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_alr1721_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1269813"]),
        None,
        Some("."),
        Some("ATUL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium sp. KJJ nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1270193.JARP01000001_gene2235";
/// let this_library_node_name2 = "1270193.JARP01000011_gene3669";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_sp_kjj_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_sp_kjj_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_sp_kjj_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_sp_kjj_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1270193"]),
        None,
        Some("."),
        Some("JARP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pedobacter sp. R2019 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1270196.JCKI01000001_gene3439";
/// let this_library_node_name2 = "1270196.JCKI01000016_gene2775";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pedobacter_sp_r2019_node_name(this_library_node_name1));
/// assert!(is_valid_string_pedobacter_sp_r2019_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pedobacter_sp_r2019_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pedobacter_sp_r2019_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1270196"]),
        None,
        Some("."),
        Some("JCKI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Megasphaera sp. NM10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1273103.NM10_00005";
/// let this_library_node_name2 = "1273103.NM10_13539";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_megasphaera_sp_nm10_node_name(this_library_node_name1));
/// assert!(is_valid_string_megasphaera_sp_nm10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_megasphaera_sp_nm10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_megasphaera_sp_nm10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1273103"]),
        None,
        Some("."),
        Some("NM10_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus rhodnii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1273125.Rrhod_0001";
/// let this_library_node_name2 = "1273125.Rrhod_4478";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_rhodnii_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_rhodnii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_rhodnii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_rhodnii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1273125"]),
        None,
        Some("."),
        Some("Rrhod_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Planomicrobium glaciei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1273538.G159_00005";
/// let this_library_node_name2 = "1273538.G159_20015";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_planomicrobium_glaciei_node_name(this_library_node_name1));
/// assert!(is_valid_string_planomicrobium_glaciei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_planomicrobium_glaciei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_planomicrobium_glaciei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1273538"]),
        None,
        Some("."),
        Some("G159_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. GD11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1274374.CBLK010000001_gene3410";
/// let this_library_node_name2 = "1274374.CBLK010000091_gene4698";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_gd11_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_gd11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_gd11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_gd11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1274374"]),
        None,
        Some("."),
        Some("CBLK0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hepatobacter penaei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1274402.JQAJ01000001_gene1";
/// let this_library_node_name2 = "1274402.JQAJ01000005_gene967";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hepatobacter_penaei_node_name(this_library_node_name1));
/// assert!(is_valid_string_hepatobacter_penaei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hepatobacter_penaei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hepatobacter_penaei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1274402"]),
        None,
        Some("."),
        Some("JQAJ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sonorensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1274524.BSONL12_00005";
/// let this_library_node_name2 = "1274524.BSONL12_23916";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sonorensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sonorensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sonorensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sonorensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1274524"]),
        None,
        Some("."),
        Some("BSONL12_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiroplasma taiwanense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1276220.STAIW_v1c00010";
/// let this_library_node_name2 = "1276220.STAIW_v1c11210";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiroplasma_taiwanense_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiroplasma_taiwanense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiroplasma_taiwanense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiroplasma_taiwanense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1276220"]),
        None,
        Some("."),
        Some("STAIW_v1c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiroplasma diminutum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1276221.SDIMI_v3c00010";
/// let this_library_node_name2 = "1276221.SDIMI_v3c08580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiroplasma_diminutum_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiroplasma_diminutum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiroplasma_diminutum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiroplasma_diminutum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1276221"]),
        None,
        Some("."),
        Some("SDIMI_v3c0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiroplasma chrysopicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1276227.SCHRY_v1c00010";
/// let this_library_node_name2 = "1276227.SCHRY_v1c10240";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiroplasma_chrysopicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiroplasma_chrysopicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiroplasma_chrysopicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiroplasma_chrysopicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1276227"]),
        None,
        Some("."),
        Some("SCHRY_v1c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiroplasma syrphidicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1276229.SSYRP_v1c00010";
/// let this_library_node_name2 = "1276229.SSYRP_v1c10150";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiroplasma_syrphidicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiroplasma_syrphidicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiroplasma_syrphidicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiroplasma_syrphidicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1276229"]),
        None,
        Some("."),
        Some("SSYRP_v1c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiroplasma culicicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1276246.SCULI_v1c00010";
/// let this_library_node_name2 = "1276246.SCULI_v1c10720";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiroplasma_culicicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiroplasma_culicicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiroplasma_culicicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiroplasma_culicicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1276246"]),
        None,
        Some("."),
        Some("SCULI_v1c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiroplasma sabaudiense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1276257.SSABA_v1c00010";
/// let this_library_node_name2 = "1276257.SSABA_v1c09380";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiroplasma_sabaudiense_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiroplasma_sabaudiense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiroplasma_sabaudiense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiroplasma_sabaudiense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1276257"]),
        None,
        Some("."),
        Some("SSABA_v1c0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiroplasma apis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1276258.SAPIS_v1c00010";
/// let this_library_node_name2 = "1276258.SAPIS_v1c10010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiroplasma_apis_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiroplasma_apis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiroplasma_apis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiroplasma_apis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1276258"]),
        None,
        Some("."),
        Some("SAPIS_v1c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidovorax sp. JHL9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1276756.AUEX01000001_gene1000";
/// let this_library_node_name2 = "1276756.AUEX01000066_gene1690";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidovorax_sp_jhl9_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidovorax_sp_jhl9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidovorax_sp_jhl9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidovorax_sp_jhl9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1276756"]),
        None,
        Some("."),
        Some("AUEX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter gangotriensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1276920.ADIAG_00001";
/// let this_library_node_name2 = "1276920.ADIAG_04082";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_gangotriensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_gangotriensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_gangotriensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_gangotriensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1276920"]),
        None,
        Some("."),
        Some("ADIAG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myxococcus stipitatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1278073.MYSTI_00001";
/// let this_library_node_name2 = "1278073.MYSTI_08136";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myxococcus_stipitatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_myxococcus_stipitatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myxococcus_stipitatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myxococcus_stipitatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1278073"]),
        None,
        Some("."),
        Some("MYSTI_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus triatomae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1278078.G419_00005";
/// let this_library_node_name2 = "1278078.G419_26544";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_triatomae_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_triatomae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_triatomae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_triatomae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1278078"]),
        None,
        Some("."),
        Some("G419_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acholeplasma granularum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1278304.JAFR01000001_gene611";
/// let this_library_node_name2 = "1278304.JAFR01000014_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acholeplasma_granularum_node_name(this_library_node_name1));
/// assert!(is_valid_string_acholeplasma_granularum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acholeplasma_granularum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acholeplasma_granularum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1278304"]),
        None,
        Some("."),
        Some("JAFR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium russii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1278306.KB906906_gene153";
/// let this_library_node_name2 = "1278306.KB906946_gene1715";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_russii_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_russii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_russii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_russii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1278306"]),
        None,
        Some("."),
        Some("KB9069"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychromonas ossibalaenae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1278307.KB906967_gene2408";
/// let this_library_node_name2 = "1278307.KB907073_gene2700";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychromonas_ossibalaenae_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychromonas_ossibalaenae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychromonas_ossibalaenae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychromonas_ossibalaenae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1278307"]),
        None,
        Some("."),
        Some("KB90"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zimmermannella faecalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1278308.KB907074_gene1000";
/// let this_library_node_name2 = "1278308.KB907089_gene243";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zimmermannella_faecalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_zimmermannella_faecalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zimmermannella_faecalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zimmermannella_faecalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1278308"]),
        None,
        Some("."),
        Some("KB9070"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Amphritea japonica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1278309.KB907099_gene2364";
/// let this_library_node_name2 = "1278309.KB907120_gene3";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_amphritea_japonica_node_name(this_library_node_name1));
/// assert!(is_valid_string_amphritea_japonica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_amphritea_japonica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_amphritea_japonica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1278309"]),
        None,
        Some("."),
        Some("KB907"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acholeplasma axanthum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1278311.AUAL01000001_gene1";
/// let this_library_node_name2 = "1278311.AUAL01000060_gene1463";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acholeplasma_axanthum_node_name(this_library_node_name1));
/// assert!(is_valid_string_acholeplasma_axanthum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acholeplasma_axanthum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acholeplasma_axanthum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1278311"]),
        None,
        Some("."),
        Some("AUAL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Avibacterium paragallinarum 221 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1278971.AOGF01000001_gene2469";
/// let this_library_node_name2 = "1278971.AOGF01000135_gene474";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_avibacterium_paragallinarum_221_node_name(this_library_node_name1));
/// assert!(is_valid_string_avibacterium_paragallinarum_221_node_name(this_library_node_name2));
/// assert!(!is_valid_string_avibacterium_paragallinarum_221_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_avibacterium_paragallinarum_221_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1278971"]),
        None,
        Some("."),
        Some("AOGF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cesiribacter andamanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1279009.ADICEAN_00001";
/// let this_library_node_name2 = "1279009.ADICEAN_04267";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cesiribacter_andamanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_cesiribacter_andamanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cesiribacter_andamanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cesiribacter_andamanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1279009"]),
        None,
        Some("."),
        Some("ADICEAN_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanimonas smirnovii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1279015.KB908454_gene1000";
/// let this_library_node_name2 = "1279015.KB908480_gene2971";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanimonas_smirnovii_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanimonas_smirnovii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanimonas_smirnovii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanimonas_smirnovii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1279015"]),
        None,
        Some("."),
        Some("KB9084"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbulbifer variabilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1279017.AQYJ01000001_gene402";
/// let this_library_node_name2 = "1279017.AQYJ01000029_gene4003";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbulbifer_variabilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbulbifer_variabilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbulbifer_variabilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbulbifer_variabilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1279017"]),
        None,
        Some("."),
        Some("AQYJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio thiocyanoxidans ARh2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1279019.ARQK01000001_gene1351";
/// let this_library_node_name2 = "1279019.ARQK01000061_gene1876";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_thiocyanoxidans_arh2_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_thiocyanoxidans_arh2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_thiocyanoxidans_arh2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_thiocyanoxidans_arh2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1279019"]),
        None,
        Some("."),
        Some("ARQK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Novispirillum itersonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1279038.KB907337_gene100";
/// let this_library_node_name2 = "1279038.KB907369_gene33";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_novispirillum_itersonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_novispirillum_itersonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_novispirillum_itersonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_novispirillum_itersonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1279038"]),
        None,
        Some("."),
        Some("KB9073"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio jasicida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280001.BAOA01000001_gene4508";
/// let this_library_node_name2 = "1280001.BAOA01000282_gene1032";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_jasicida_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_jasicida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_jasicida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_jasicida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280001"]),
        None,
        Some("."),
        Some("BAOA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. KORDI100 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280380.KR100_00005";
/// let this_library_node_name2 = "1280380.KR100_15610";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_kordi100_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_kordi100_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_kordi100_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_kordi100_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280380"]),
        None,
        Some("."),
        Some("KR100_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillaceae bacterium G5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280390.CBQR020000001_gene1";
/// let this_library_node_name2 = "1280390.CBQR020000189_gene4792";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillaceae_bacterium_g5_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillaceae_bacterium_g5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillaceae_bacterium_g5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillaceae_bacterium_g5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280390"]),
        None,
        Some("."),
        Some("CBQR020000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. AE2015 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280663.ATVR01000001_gene381";
/// let this_library_node_name2 = "1280663.ATVR01000073_gene767";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_ae2015_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_ae2015_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_ae2015_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_ae2015_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280663"]),
        None,
        Some("."),
        Some("ATVR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. VCD2006 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280664.AUIX01000001_gene564";
/// let this_library_node_name2 = "1280664.AUIX01000080_gene948";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_vcd2006_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_vcd2006_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_vcd2006_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_vcd2006_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280664"]),
        None,
        Some("."),
        Some("AUIX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. AE3009 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280666.ATVS01000001_gene3102";
/// let this_library_node_name2 = "1280666.ATVS01000103_gene2909";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_ae3009_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_ae3009_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_ae3009_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_ae3009_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280666"]),
        None,
        Some("."),
        Some("ATVS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. XPD2006 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280668.ATVT01000001_gene1000";
/// let this_library_node_name2 = "1280668.ATVT01000030_gene3394";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_xpd2006_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_xpd2006_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_xpd2006_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_xpd2006_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280668"]),
        None,
        Some("."),
        Some("ATVT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. FC2001 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280671.AUJH01000001_gene2282";
/// let this_library_node_name2 = "1280671.AUJH01000045_gene1547";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_fc2001_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_fc2001_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_fc2001_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_fc2001_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280671"]),
        None,
        Some("."),
        Some("AUJH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. AE3006 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280673.AUJJ01000001_gene2064";
/// let this_library_node_name2 = "1280673.AUJJ01000045_gene3445";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_ae3006_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_ae3006_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_ae3006_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_ae3006_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280673"]),
        None,
        Some("."),
        Some("AUJJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. AGR2160 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280674.AUJK01000001_gene1000";
/// let this_library_node_name2 = "1280674.AUJK01000048_gene1113";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_agr2160_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_agr2160_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_agr2160_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_agr2160_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280674"]),
        None,
        Some("."),
        Some("AUJK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. WCD3002 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280676.AUJO01000001_gene2194";
/// let this_library_node_name2 = "1280676.AUJO01000053_gene770";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_wcd3002_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_wcd3002_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_wcd3002_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_wcd3002_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280676"]),
        None,
        Some("."),
        Some("AUJO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. VCB2006 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280679.ATVX01000001_gene2670";
/// let this_library_node_name2 = "1280679.ATVX01000040_gene3257";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_vcb2006_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_vcb2006_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_vcb2006_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_vcb2006_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280679"]),
        None,
        Some("."),
        Some("ATVX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. LC3010 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280680.AUJU01000001_gene1616";
/// let this_library_node_name2 = "1280680.AUJU01000069_gene3801";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_lc3010_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_lc3010_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_lc3010_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_lc3010_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280680"]),
        None,
        Some("."),
        Some("AUJU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. WCD2001 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280681.AUJZ01000001_gene1000";
/// let this_library_node_name2 = "1280681.AUJZ01000060_gene2326";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_wcd2001_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_wcd2001_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_wcd2001_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_wcd2001_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280681"]),
        None,
        Some("."),
        Some("AUJZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. XBB1001 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280682.AUKA01000001_gene1480";
/// let this_library_node_name2 = "1280682.AUKA01000041_gene2401";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_xbb1001_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_xbb1001_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_xbb1001_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_xbb1001_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280682"]),
        None,
        Some("."),
        Some("AUKA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. NC3005 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280685.AUKC01000001_gene3134";
/// let this_library_node_name2 = "1280685.AUKC01000096_gene1445";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_nc3005_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_nc3005_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_nc3005_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_nc3005_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280685"]),
        None,
        Some("."),
        Some("AUKC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. MC2013 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280686.AUKE01000001_gene2025";
/// let this_library_node_name2 = "1280686.AUKE01000050_gene925";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_mc2013_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_mc2013_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_mc2013_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_mc2013_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280686"]),
        None,
        Some("."),
        Some("AUKE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudobutyrivibrio ruminis CF1b nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280688.AUJB01000001_gene218";
/// let this_library_node_name2 = "1280688.AUJB01000017_gene1435";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudobutyrivibrio_ruminis_cf1b_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudobutyrivibrio_ruminis_cf1b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudobutyrivibrio_ruminis_cf1b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudobutyrivibrio_ruminis_cf1b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280688"]),
        None,
        Some("."),
        Some("AUJB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium paraputrificum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280689.AUJC01000001_gene1988";
/// let this_library_node_name2 = "1280689.AUJC01000032_gene1951";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_paraputrificum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_paraputrificum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_paraputrificum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_paraputrificum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280689"]),
        None,
        Some("."),
        Some("AUJC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium cadaveris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280692.AUJL01000001_gene100";
/// let this_library_node_name2 = "1280692.AUJL01000045_gene2229";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_cadaveris_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_cadaveris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_cadaveris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_cadaveris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280692"]),
        None,
        Some("."),
        Some("AUJL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudobutyrivibrio ruminis AD2017 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280694.AUJQ01000001_gene1877";
/// let this_library_node_name2 = "1280694.AUJQ01000022_gene1119";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudobutyrivibrio_ruminis_ad2017_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudobutyrivibrio_ruminis_ad2017_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudobutyrivibrio_ruminis_ad2017_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudobutyrivibrio_ruminis_ad2017_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280694"]),
        None,
        Some("."),
        Some("AUJQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio fibrisolvens ND3005 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280696.ATVY01000001_gene3519";
/// let this_library_node_name2 = "1280696.ATVY01000160_gene2993";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_fibrisolvens_nd3005_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_fibrisolvens_nd3005_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_fibrisolvens_nd3005_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_fibrisolvens_nd3005_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280696"]),
        None,
        Some("."),
        Some("ATVY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dorea longicatena AGR2136 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280698.AUJS01000001_gene3081";
/// let this_library_node_name2 = "1280698.AUJS01000144_gene1842";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dorea_longicatena_agr2136_node_name(this_library_node_name1));
/// assert!(is_valid_string_dorea_longicatena_agr2136_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dorea_longicatena_agr2136_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dorea_longicatena_agr2136_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280698"]),
        None,
        Some("."),
        Some("AUJS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas ruminantium ATCC12561 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280706.AUJE01000001_gene1843";
/// let this_library_node_name2 = "1280706.AUJE01000071_gene1099";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_ruminantium_atcc12561_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_ruminantium_atcc12561_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_ruminantium_atcc12561_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_ruminantium_atcc12561_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280706"]),
        None,
        Some("."),
        Some("AUJE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas sp. T16B2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280941.HY2_00005";
/// let this_library_node_name2 = "1280941.HY2_16890";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_sp_t16b2_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_sp_t16b2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_sp_t16b2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_sp_t16b2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280941"]),
        None,
        Some("."),
        Some("HY2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas sp. CY54118 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280944.HY17_00005";
/// let this_library_node_name2 = "1280944.HY17_19500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_sp_cy54118_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_sp_cy54118_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_sp_cy54118_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_sp_cy54118_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280944"]),
        None,
        Some("."),
        Some("HY17_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas sp. 25B141 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280946.HY29_00005";
/// let this_library_node_name2 = "1280946.HY29_18645";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_sp_25b141_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_sp_25b141_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_sp_25b141_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_sp_25b141_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280946"]),
        None,
        Some("."),
        Some("HY29_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas sp. BHBN044 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280947.HY30_00005";
/// let this_library_node_name2 = "1280947.HY30_19350";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_sp_bhbn044_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_sp_bhbn044_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_sp_bhbn044_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_sp_bhbn044_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280947"]),
        None,
        Some("."),
        Some("HY30_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas sp. 22II122F38 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280948.HY36_00005";
/// let this_library_node_name2 = "1280948.HY36_17975";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_sp_22ii122f38_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_sp_22ii122f38_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_sp_22ii122f38_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_sp_22ii122f38_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280948"]),
        None,
        Some("."),
        Some("HY36_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas adhaerens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280949.HAD_00005";
/// let this_library_node_name2 = "1280949.HAD_17516";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_adhaerens_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_adhaerens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_adhaerens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_adhaerens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280949"]),
        None,
        Some("."),
        Some("HAD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas johnsonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280950.HJO_00005";
/// let this_library_node_name2 = "1280950.HJO_17369";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_johnsonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_johnsonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_johnsonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_johnsonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280950"]),
        None,
        Some("."),
        Some("HJO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas jannaschiana nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280952.HJA_00005";
/// let this_library_node_name2 = "1280952.HJA_17617";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_jannaschiana_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_jannaschiana_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_jannaschiana_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_jannaschiana_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280952"]),
        None,
        Some("."),
        Some("HJA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas oceanitis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280953.HOC_00005";
/// let this_library_node_name2 = "1280953.HOC_21038";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_oceanitis_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_oceanitis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_oceanitis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_oceanitis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280953"]),
        None,
        Some("."),
        Some("HOC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hyphomonas polymorpha nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1280954.HPO_00005";
/// let this_library_node_name2 = "1280954.HPO_19414";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hyphomonas_polymorpha_node_name(this_library_node_name1));
/// assert!(is_valid_string_hyphomonas_polymorpha_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hyphomonas_polymorpha_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hyphomonas_polymorpha_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1280954"]),
        None,
        Some("."),
        Some("HPO_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Agrobacterium tumefaciens Cherry nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1281779.H009_00005";
/// let this_library_node_name2 = "1281779.H009_25480";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_agrobacterium_tumefaciens_cherry_node_name(this_library_node_name1));
/// assert!(is_valid_string_agrobacterium_tumefaciens_cherry_node_name(this_library_node_name2));
/// assert!(!is_valid_string_agrobacterium_tumefaciens_cherry_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_agrobacterium_tumefaciens_cherry_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1281779"]),
        None,
        Some("."),
        Some("H009_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas poae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1282356.H045_00005";
/// let this_library_node_name2 = "1282356.H045_24070";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_poae_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_poae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_poae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_poae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1282356"]),
        None,
        Some("."),
        Some("H045_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Asticcacaulis sp. AC460 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1282360.ABAC460_00010";
/// let this_library_node_name2 = "1282360.ABAC460_23950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_asticcacaulis_sp_ac460_node_name(this_library_node_name1));
/// assert!(is_valid_string_asticcacaulis_sp_ac460_node_name(this_library_node_name2));
/// assert!(!is_valid_string_asticcacaulis_sp_ac460_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_asticcacaulis_sp_ac460_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1282360"]),
        None,
        Some("."),
        Some("ABAC460_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Asticcacaulis sp. AC402 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1282361.ABAC402_00005";
/// let this_library_node_name2 = "1282361.ABAC402_19485";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_asticcacaulis_sp_ac402_node_name(this_library_node_name1));
/// assert!(is_valid_string_asticcacaulis_sp_ac402_node_name(this_library_node_name2));
/// assert!(!is_valid_string_asticcacaulis_sp_ac402_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_asticcacaulis_sp_ac402_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1282361"]),
        None,
        Some("."),
        Some("ABAC402_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Asticcacaulis sp. AC466 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1282362.AEAC466_00010";
/// let this_library_node_name2 = "1282362.AEAC466_21850";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_asticcacaulis_sp_ac466_node_name(this_library_node_name1));
/// assert!(is_valid_string_asticcacaulis_sp_ac466_node_name(this_library_node_name2));
/// assert!(!is_valid_string_asticcacaulis_sp_ac466_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_asticcacaulis_sp_ac466_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1282362"]),
        None,
        Some("."),
        Some("AEAC466_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus tigurinus AZ3a nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1282664.H354_00005";
/// let this_library_node_name2 = "1282664.H354_10920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_tigurinus_az3a_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_tigurinus_az3a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_tigurinus_az3a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_tigurinus_az3a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1282664"]),
        None,
        Some("."),
        Some("H354_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus tigurinus 1366 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1282665.H353_00005";
/// let this_library_node_name2 = "1282665.H353_09318";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_tigurinus_1366_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_tigurinus_1366_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_tigurinus_1366_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_tigurinus_1366_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1282665"]),
        None,
        Some("."),
        Some("H353_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING alpha proteobacterium Mf 105b01 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1282876.BAOK01000001_gene1000";
/// let this_library_node_name2 = "1282876.BAOK01000002_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alpha_proteobacterium_mf_105b01_node_name(this_library_node_name1));
/// assert!(is_valid_string_alpha_proteobacterium_mf_105b01_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alpha_proteobacterium_mf_105b01_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alpha_proteobacterium_mf_105b01_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1282876"]),
        None,
        Some("."),
        Some("BAOK0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospira multipara ATCC19207 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1282887.AUJG01000001_gene1491";
/// let this_library_node_name2 = "1282887.AUJG01000032_gene356";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospira_multipara_atcc19207_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospira_multipara_atcc19207_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospira_multipara_atcc19207_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospira_multipara_atcc19207_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1282887"]),
        None,
        Some("."),
        Some("AUJG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Frankia sp. Iso899 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1283283.ATXA01000001_gene1000";
/// let this_library_node_name2 = "1283283.ATXA01000067_gene2383";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_frankia_sp_iso899_node_name(this_library_node_name1));
/// assert!(is_valid_string_frankia_sp_iso899_node_name(this_library_node_name2));
/// assert!(!is_valid_string_frankia_sp_iso899_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_frankia_sp_iso899_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1283283"]),
        None,
        Some("."),
        Some("ATXA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tolumonas sp. BRL61 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1283284.AZUK01000001_gene1";
/// let this_library_node_name2 = "1283284.AZUK01000009_gene3104";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tolumonas_sp_brl61_node_name(this_library_node_name1));
/// assert!(is_valid_string_tolumonas_sp_brl61_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tolumonas_sp_brl61_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tolumonas_sp_brl61_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1283284"]),
        None,
        Some("."),
        Some("AZUK0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardioides sp. Iso805N nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1283287.KB822575_gene1";
/// let this_library_node_name2 = "1283287.KB822598_gene2875";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardioides_sp_iso805n_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardioides_sp_iso805n_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardioides_sp_iso805n_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardioides_sp_iso805n_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1283287"]),
        None,
        Some("."),
        Some("KB8225"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Conexibacter woesei Iso977N nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1283299.AUKG01000001_gene1257";
/// let this_library_node_name2 = "1283299.AUKG01000010_gene180";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_conexibacter_woesei_iso977n_node_name(this_library_node_name1));
/// assert!(is_valid_string_conexibacter_woesei_iso977n_node_name(this_library_node_name2));
/// assert!(!is_valid_string_conexibacter_woesei_iso977n_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_conexibacter_woesei_iso977n_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1283299"]),
        None,
        Some("."),
        Some("AUKG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylohalobius crimeensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1283300.ATXB01000001_gene100";
/// let this_library_node_name2 = "1283300.ATXB01000005_gene6";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylohalobius_crimeensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylohalobius_crimeensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylohalobius_crimeensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylohalobius_crimeensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1283300"]),
        None,
        Some("."),
        Some("ATXB0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. A9 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1284352.AOIG01000001_gene3087";
/// let this_library_node_name2 = "1284352.AOIG01000067_gene790";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_a9_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_a9_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_a9_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_a9_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1284352"]),
        None,
        Some("."),
        Some("AOIG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces urogenitalis S6C4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1284679.HMPREF1626_00005";
/// let this_library_node_name2 = "1284679.HMPREF1626_11485";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_urogenitalis_s6c4_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_urogenitalis_s6c4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_urogenitalis_s6c4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_urogenitalis_s6c4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1284679"]),
        None,
        Some("."),
        Some("HMPREF1626_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. S6Spd3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1284680.HMPREF1627_00010";
/// let this_library_node_name2 = "1284680.HMPREF1627_10310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_s6spd3_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_s6spd3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_s6spd3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_s6spd3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1284680"]),
        None,
        Some("."),
        Some("HMPREF1627_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerococcus lactolyticus S7113 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1284686.HMPREF1630_00010";
/// let this_library_node_name2 = "1284686.HMPREF1630_09460";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerococcus_lactolyticus_s7113_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerococcus_lactolyticus_s7113_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerococcus_lactolyticus_s7113_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerococcus_lactolyticus_s7113_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1284686"]),
        None,
        Some("."),
        Some("HMPREF1630_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium S714 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1284708.HMPREF1634_00005";
/// let this_library_node_name2 = "1284708.HMPREF1634_08820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_s714_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_s714_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_s714_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_s714_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1284708"]),
        None,
        Some("."),
        Some("HMPREF1634_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. S718 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1284775.HMPREF1640_00015";
/// let this_library_node_name2 = "1284775.HMPREF1640_13840";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_s718_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_s718_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_s718_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_s718_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1284775"]),
        None,
        Some("."),
        Some("HMPREF1640_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium casei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1285583.CCASEI_00005";
/// let this_library_node_name2 = "1285583.CCASEI_14368";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_casei_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_casei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_casei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_casei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1285583"]),
        None,
        Some("."),
        Some("CCASEI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysinibacillus sphaericus OT4b31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1285586.H131_00005";
/// let this_library_node_name2 = "1285586.H131_23199";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysinibacillus_sphaericus_ot4b31_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysinibacillus_sphaericus_ot4b31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysinibacillus_sphaericus_ot4b31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysinibacillus_sphaericus_ot4b31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1285586"]),
        None,
        Some("."),
        Some("H131_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pandoraea sp. SD62 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1286093.C266_00005";
/// let this_library_node_name2 = "1286093.C266_26001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pandoraea_sp_sd62_node_name(this_library_node_name1));
/// assert!(is_valid_string_pandoraea_sp_sd62_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pandoraea_sp_sd62_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pandoraea_sp_sd62_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1286093"]),
        None,
        Some("."),
        Some("C266_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylophaga lonarensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1286106.MPL1_00005";
/// let this_library_node_name2 = "1286106.MPL1_13400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylophaga_lonarensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylophaga_lonarensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylophaga_lonarensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylophaga_lonarensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1286106"]),
        None,
        Some("."),
        Some("MPL1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Raoultella ornithinolytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1286170.RORB6_00005";
/// let this_library_node_name2 = "1286170.RORB6_24650";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_raoultella_ornithinolytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_raoultella_ornithinolytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_raoultella_ornithinolytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_raoultella_ornithinolytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1286170"]),
        None,
        Some("."),
        Some("RORB6_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium acidaminophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1286171.EAL2_808p00010";
/// let this_library_node_name2 = "1286171.EAL2_c22270";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_acidaminophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_acidaminophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_acidaminophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_acidaminophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1286171"]),
        None,
        Some("."),
        Some("EAL2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphaerotilus natans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1286631.X805_00010";
/// let this_library_node_name2 = "1286631.X805_41780";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphaerotilus_natans_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphaerotilus_natans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphaerotilus_natans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphaerotilus_natans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1286631"]),
        None,
        Some("."),
        Some("X805_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zhouia amylolytica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1286632.P278_00010";
/// let this_library_node_name2 = "1286632.P278_33710";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zhouia_amylolytica_node_name(this_library_node_name1));
/// assert!(is_valid_string_zhouia_amylolytica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zhouia_amylolytica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zhouia_amylolytica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1286632"]),
        None,
        Some("."),
        Some("P278_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium sp. L2C084A000 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1287116.X734_00005";
/// let this_library_node_name2 = "1287116.X734_33370";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_sp_l2c084a000_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_sp_l2c084a000_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_sp_l2c084a000_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_sp_l2c084a000_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1287116"]),
        None,
        Some("."),
        Some("X734_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium sp. LNJC398B00 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1287276.X752_00005";
/// let this_library_node_name2 = "1287276.X752_29645";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_sp_lnjc398b00_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_sp_lnjc398b00_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_sp_lnjc398b00_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_sp_lnjc398b00_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1287276"]),
        None,
        Some("."),
        Some("X752_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium freneyi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1287475.HMPREF1650_00005";
/// let this_library_node_name2 = "1287475.HMPREF1650_13605";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_freneyi_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_freneyi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_freneyi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_freneyi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1287475"]),
        None,
        Some("."),
        Some("HMPREF1650_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella bivia DNF00188 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1287476.HMPREF1651_00005";
/// let this_library_node_name2 = "1287476.HMPREF1651_11355";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_bivia_dnf00188_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_bivia_dnf00188_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_bivia_dnf00188_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_bivia_dnf00188_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1287476"]),
        None,
        Some("."),
        Some("HMPREF1651_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. S7 MS 2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1287488.HMPREF0671_00005";
/// let this_library_node_name2 = "1287488.HMPREF0671_12155";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_s7_ms_2_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_s7_ms_2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_s7_ms_2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_s7_ms_2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1287488"]),
        None,
        Some("."),
        Some("HMPREF0671_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. CNT318 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1288079.AUKN01000001_gene3980";
/// let this_library_node_name2 = "1288079.AUKN01000061_gene3296";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_cnt318_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_cnt318_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_cnt318_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_cnt318_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1288079"]),
        None,
        Some("."),
        Some("AUKN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. TAA040 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1288083.AUKR01000001_gene1046";
/// let this_library_node_name2 = "1288083.AUKR01000075_gene416";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_taa040_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_taa040_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_taa040_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_taa040_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1288083"]),
        None,
        Some("."),
        Some("AUKR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseovarius mucosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1288298.rosmuc_00001";
/// let this_library_node_name2 = "1288298.rosmuc_04261";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseovarius_mucosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseovarius_mucosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseovarius_mucosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseovarius_mucosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1288298"]),
        None,
        Some("."),
        Some("rosmuc_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus wulumuqiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1288484.APCS01000001_gene521";
/// let this_library_node_name2 = "1288484.APCS01000232_gene1436";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_wulumuqiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_wulumuqiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_wulumuqiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_wulumuqiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1288484"]),
        None,
        Some("."),
        Some("APCS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrosospira sp. APG3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1288494.EBAPG3_10";
/// let this_library_node_name2 = "1288494.EBAPG3_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrosospira_sp_apg3_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrosospira_sp_apg3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrosospira_sp_apg3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrosospira_sp_apg3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1288494"]),
        None,
        Some("."),
        Some("EBAPG3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter santoriniensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1288826.MSNKSG1_00011";
/// let this_library_node_name2 = "1288826.MSNKSG1_18664";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_santoriniensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_santoriniensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_santoriniensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_santoriniensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1288826"]),
        None,
        Some("."),
        Some("MSNKSG1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyclobacteriaceae bacterium AK24 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1288963.ADIS_0001";
/// let this_library_node_name2 = "1288963.ADIS_4867";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyclobacteriaceae_bacterium_ak24_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyclobacteriaceae_bacterium_ak24_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyclobacteriaceae_bacterium_ak24_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyclobacteriaceae_bacterium_ak24_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1288963"]),
        None,
        Some("."),
        Some("ADIS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brachyspira hampsonii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1289135.A966_00005";
/// let this_library_node_name2 = "1289135.A966_13665";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brachyspira_hampsonii_node_name(this_library_node_name1));
/// assert!(is_valid_string_brachyspira_hampsonii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brachyspira_hampsonii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brachyspira_hampsonii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1289135"]),
        None,
        Some("."),
        Some("A966_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. TAA204 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1289387.AUKW01000001_gene4831";
/// let this_library_node_name2 = "1289387.AUKW01000043_gene2707";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_taa204_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_taa204_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_taa204_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_taa204_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1289387"]),
        None,
        Some("."),
        Some("AUKW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium josui nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1291050.JAGE01000001_gene1";
/// let this_library_node_name2 = "1291050.JAGE01000002_gene3979";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_josui_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_josui_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_josui_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_josui_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1291050"]),
        None,
        Some("."),
        Some("JAGE0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus oryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1291743.LOSG293_010010";
/// let this_library_node_name2 = "1291743.LOSG293_930010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_oryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_oryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_oryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_oryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1291743"]),
        None,
        Some("."),
        Some("LOSG293_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dietzia sp. UCDTHP nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1292020.H483_0100020";
/// let this_library_node_name2 = "1292020.H483_0118850";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dietzia_sp_ucdthp_node_name(this_library_node_name1));
/// assert!(is_valid_string_dietzia_sp_ucdthp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dietzia_sp_ucdthp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dietzia_sp_ucdthp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1292020"]),
        None,
        Some("."),
        Some("H483_01"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma putrefaciens Mput9231 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1292033.MPUT9231_0010";
/// let this_library_node_name2 = "1292033.MPUT9231_7400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_putrefaciens_mput9231_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_putrefaciens_mput9231_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_putrefaciens_mput9231_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_putrefaciens_mput9231_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1292033"]),
        None,
        Some("."),
        Some("MPUT9231_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caulobacter crescentus OR37 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1292034.OR37_00001";
/// let this_library_node_name2 = "1292034.OR37_04153";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caulobacter_crescentus_or37_node_name(this_library_node_name1));
/// assert!(is_valid_string_caulobacter_crescentus_or37_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caulobacter_crescentus_or37_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caulobacter_crescentus_or37_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1292034"]),
        None,
        Some("."),
        Some("OR37_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sordellii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1292035.H476_0001";
/// let this_library_node_name2 = "1292035.H476_3630";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sordellii_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sordellii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sordellii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sordellii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1292035"]),
        None,
        Some("."),
        Some("H476_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacterium granulosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1292373.H640_00005";
/// let this_library_node_name2 = "1292373.H640_09192";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacterium_granulosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacterium_granulosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacterium_granulosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacterium_granulosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1292373"]),
        None,
        Some("."),
        Some("H640_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halopiger sp. IIH2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1293047.CBMA010000001_gene1";
/// let this_library_node_name2 = "1293047.CBMA010000054_gene3583";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halopiger_sp_iih2_node_name(this_library_node_name1));
/// assert!(is_valid_string_halopiger_sp_iih2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halopiger_sp_iih2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halopiger_sp_iih2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1293047"]),
        None,
        Some("."),
        Some("CBMA0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halopiger sp. IIH3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1293048.CBMB010000001_gene1";
/// let this_library_node_name2 = "1293048.CBMB010000010_gene3729";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halopiger_sp_iih3_node_name(this_library_node_name1));
/// assert!(is_valid_string_halopiger_sp_iih3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halopiger_sp_iih3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halopiger_sp_iih3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1293048"]),
        None,
        Some("."),
        Some("CBMB0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halanaerobium saccharolyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1293054.HSACCH_00001";
/// let this_library_node_name2 = "1293054.HSACCH_02664";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halanaerobium_saccharolyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_halanaerobium_saccharolyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halanaerobium_saccharolyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halanaerobium_saccharolyticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1293054"]),
        None,
        Some("."),
        Some("HSACCH_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus equicursoris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1293597.BN147_00005";
/// let this_library_node_name2 = "1293597.BN147_10325";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_equicursoris_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_equicursoris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_equicursoris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_equicursoris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1293597"]),
        None,
        Some("."),
        Some("BN147_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium intestinale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1294142.CINTURNW_0003";
/// let this_library_node_name2 = "1294142.CINTURNW_4639";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_intestinale_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_intestinale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_intestinale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_intestinale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1294142"]),
        None,
        Some("."),
        Some("CINTURNW_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas denitrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1294143.H681_00005";
/// let this_library_node_name2 = "1294143.H681_25355";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_denitrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_denitrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_denitrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_denitrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1294143"]),
        None,
        Some("."),
        Some("H681_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus boroniphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1294265.JCM21738_1";
/// let this_library_node_name2 = "1294265.JCM21738_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_boroniphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_boroniphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_boroniphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_boroniphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1294265"]),
        None,
        Some("."),
        Some("JCM21738_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseibacterium elongatum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1294273.roselon_00001";
/// let this_library_node_name2 = "1294273.roselon_03682";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseibacterium_elongatum_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseibacterium_elongatum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseibacterium_elongatum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseibacterium_elongatum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1294273"]),
        None,
        Some("."),
        Some("roselon_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacillus stearothermophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1295642.H839_00005";
/// let this_library_node_name2 = "1295642.H839_18540";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacillus_stearothermophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacillus_stearothermophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacillus_stearothermophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacillus_stearothermophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1295642"]),
        None,
        Some("."),
        Some("H839_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquimarina sp. SW150 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1296415.JACC01000001_gene3409";
/// let this_library_node_name2 = "1296415.JACC01000145_gene733";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquimarina_sp_sw150_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquimarina_sp_sw150_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquimarina_sp_sw150_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquimarina_sp_sw150_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1296415"]),
        None,
        Some("."),
        Some("JACC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquimarina megaterium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1296416.JACB01000001_gene3090";
/// let this_library_node_name2 = "1296416.JACB01000170_gene85";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquimarina_megaterium_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquimarina_megaterium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquimarina_megaterium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquimarina_megaterium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1296416"]),
        None,
        Some("."),
        Some("JACB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Komagataeibacter xylinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1296990.H845_1";
/// let this_library_node_name2 = "1296990.H845_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_komagataeibacter_xylinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_komagataeibacter_xylinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_komagataeibacter_xylinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_komagataeibacter_xylinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1296990"]),
        None,
        Some("."),
        Some("H845_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus dentisani 7746 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1297534.CAUJ01000001_gene1257";
/// let this_library_node_name2 = "1297534.CAUJ01000008_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_dentisani_7746_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_dentisani_7746_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_dentisani_7746_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_dentisani_7746_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1297534"]),
        None,
        Some("."),
        Some("CAUJ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium metallidurans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1297569.MESS2_1000002";
/// let this_library_node_name2 = "1297569.MESS2_p90057";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_metallidurans_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_metallidurans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_metallidurans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_metallidurans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1297569"]),
        None,
        Some("."),
        Some("MESS2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium sp. STM4661 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1297570.MESS4_100002";
/// let this_library_node_name2 = "1297570.MESS4_p60001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_sp_stm4661_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_sp_stm4661_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_sp_stm4661_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_sp_stm4661_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1297570"]),
        None,
        Some("."),
        Some("MESS4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anoxybacillus flavithermus AK1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1297581.H919_00005";
/// let this_library_node_name2 = "1297581.H919_13913";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anoxybacillus_flavithermus_ak1_node_name(this_library_node_name1));
/// assert!(is_valid_string_anoxybacillus_flavithermus_ak1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anoxybacillus_flavithermus_ak1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anoxybacillus_flavithermus_ak1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1297581"]),
        None,
        Some("."),
        Some("H919_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Intestinimonas butyriciproducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1297617.JPJD01000001_gene2648";
/// let this_library_node_name2 = "1297617.JPJD01000108_gene601";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_intestinimonas_butyriciproducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_intestinimonas_butyriciproducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_intestinimonas_butyriciproducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_intestinimonas_butyriciproducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1297617"]),
        None,
        Some("."),
        Some("JPJD01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myxococcus sp. nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1297742.A176_00001";
/// let this_library_node_name2 = "1297742.A176_07692";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myxococcus_sp_node_name(this_library_node_name1));
/// assert!(is_valid_string_myxococcus_sp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myxococcus_sp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myxococcus_sp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1297742"]),
        None,
        Some("."),
        Some("A176_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus dentisani 7747 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1297857.CAUK01000001_gene1618";
/// let this_library_node_name2 = "1297857.CAUK01000006_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_dentisani_7747_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_dentisani_7747_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_dentisani_7747_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_dentisani_7747_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1297857"]),
        None,
        Some("."),
        Some("CAUK0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Afipia sp. OHSUIC4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1297863.APJF01000001_gene1932";
/// let this_library_node_name2 = "1297863.APJF01000050_gene5";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_afipia_sp_ohsuic4_node_name(this_library_node_name1));
/// assert!(is_valid_string_afipia_sp_ohsuic4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_afipia_sp_ohsuic4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_afipia_sp_ohsuic4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1297863"]),
        None,
        Some("."),
        Some("APJF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. OHSUIII nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1297865.APJD01000001_gene5818";
/// let this_library_node_name2 = "1297865.APJD01000082_gene7060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_ohsuiii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_ohsuiii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_ohsuiii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_ohsuiii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1297865"]),
        None,
        Some("."),
        Some("APJD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thalassolituus oleivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298593.TOL_0001";
/// let this_library_node_name2 = "1298593.TOL_3732";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thalassolituus_oleivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_thalassolituus_oleivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thalassolituus_oleivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thalassolituus_oleivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298593"]),
        None,
        Some("."),
        Some("TOL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gracilibacillus boraciitolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298598.JCM21714_1";
/// let this_library_node_name2 = "1298598.JCM21714_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gracilibacillus_boraciitolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_gracilibacillus_boraciitolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gracilibacillus_boraciitolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gracilibacillus_boraciitolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298598"]),
        None,
        Some("."),
        Some("JCM21714_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter sp. JCM18900 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298608.JCM18900_1";
/// let this_library_node_name2 = "1298608.JCM18900_99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_sp_jcm18900_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_sp_jcm18900_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_sp_jcm18900_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_sp_jcm18900_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298608"]),
        None,
        Some("."),
        Some("JCM18900_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium sp. URHA0056 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298858.AUEL01000001_gene4493";
/// let this_library_node_name2 = "1298858.AUEL01000038_gene493";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_sp_urha0056_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_sp_urha0056_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_sp_urha0056_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_sp_urha0056_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298858"]),
        None,
        Some("."),
        Some("AUEL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium sp. URHA0036 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298860.AUEM01000001_gene1000";
/// let this_library_node_name2 = "1298860.AUEM01000022_gene335";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_sp_urha0036_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_sp_urha0036_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_sp_urha0036_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_sp_urha0036_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298860"]),
        None,
        Some("."),
        Some("AUEM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marmoricola sp. URHB0036 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298863.AUEP01000001_gene1000";
/// let this_library_node_name2 = "1298863.AUEP01000022_gene1869";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marmoricola_sp_urhb0036_node_name(this_library_node_name1));
/// assert!(is_valid_string_marmoricola_sp_urhb0036_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marmoricola_sp_urhb0036_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marmoricola_sp_urhb0036_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298863"]),
        None,
        Some("."),
        Some("AUEP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium sp. URHD0025 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298864.AUEQ01000001_gene4028";
/// let this_library_node_name2 = "1298864.AUEQ01000033_gene4863";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_sp_urhd0025_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_sp_urhd0025_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_sp_urhd0025_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_sp_urhd0025_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298864"]),
        None,
        Some("."),
        Some("AUEQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alteromonas sp. ALT199 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298865.H978DRAFT_0001";
/// let this_library_node_name2 = "1298865.H978DRAFT_4040";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alteromonas_sp_alt199_node_name(this_library_node_name1));
/// assert!(is_valid_string_alteromonas_sp_alt199_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alteromonas_sp_alt199_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alteromonas_sp_alt199_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298865"]),
        None,
        Some("."),
        Some("H978DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. URHA0002 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298867.AUES01000001_gene1582";
/// let this_library_node_name2 = "1298867.AUES01000145_gene2143";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_urha0002_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_urha0002_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_urha0002_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_urha0002_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298867"]),
        None,
        Some("."),
        Some("AUES01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. TAA486 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298880.AUEV01000001_gene5291";
/// let this_library_node_name2 = "1298880.AUEV01000036_gene5255";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_taa486_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_taa486_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_taa486_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_taa486_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298880"]),
        None,
        Some("."),
        Some("AUEV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfotomaculum guttoideum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1298920.KI911353_gene1";
/// let this_library_node_name2 = "1298920.KI911353_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfotomaculum_guttoideum_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfotomaculum_guttoideum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfotomaculum_guttoideum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfotomaculum_guttoideum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1298920"]),
        None,
        Some("."),
        Some("KI911353_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium kansasii 732 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1299327.I546_0001";
/// let this_library_node_name2 = "1299327.I546_7359";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_kansasii_732_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_kansasii_732_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_kansasii_732_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_kansasii_732_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1299327"]),
        None,
        Some("."),
        Some("I546_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium oranimense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1300143.CCAV010000001_gene1000";
/// let this_library_node_name2 = "1300143.CCAV010000015_gene1729";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_oranimense_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_oranimense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_oranimense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_oranimense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1300143"]),
        None,
        Some("."),
        Some("CCAV0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterococcus mundtii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1300150.EMQU_0001";
/// let this_library_node_name2 = "1300150.EMQU_3196";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterococcus_mundtii_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterococcus_mundtii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterococcus_mundtii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterococcus_mundtii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1300150"]),
        None,
        Some("."),
        Some("EMQU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysobacter dokdonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1300345.LF41_1";
/// let this_library_node_name2 = "1300345.LF41_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysobacter_dokdonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysobacter_dokdonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysobacter_dokdonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysobacter_dokdonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1300345"]),
        None,
        Some("."),
        Some("LF41_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfitobacter donghicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1300350.DSW25_00005";
/// let this_library_node_name2 = "1300350.DSW25_17720";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfitobacter_donghicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfitobacter_donghicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfitobacter_donghicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfitobacter_donghicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1300350"]),
        None,
        Some("."),
        Some("DSW25_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas knackmussii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1301098.PKB_0001";
/// let this_library_node_name2 = "1301098.PKB_5824";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_knackmussii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_knackmussii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_knackmussii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_knackmussii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1301098"]),
        None,
        Some("."),
        Some("PKB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. 01 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1301100.HG529224_gene5436";
/// let this_library_node_name2 = "1301100.HG529479_gene5364";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_01_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_01_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_01_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_01_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1301100"]),
        None,
        Some("."),
        Some("HG529"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus namurensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1302286.BAOT01000001_gene1";
/// let this_library_node_name2 = "1302286.BAOT01000096_gene2232";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_namurensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_namurensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_namurensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_namurensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1302286"]),
        None,
        Some("."),
        Some("BAOT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia miyamotoi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1302858.I871_00005";
/// let this_library_node_name2 = "1302858.I871_04435";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_miyamotoi_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_miyamotoi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_miyamotoi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_miyamotoi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1302858"]),
        None,
        Some("."),
        Some("I871_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus oligofermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1302863.I872_00005";
/// let this_library_node_name2 = "1302863.I872_10680";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_oligofermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_oligofermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_oligofermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_oligofermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1302863"]),
        None,
        Some("."),
        Some("I872_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chthonomonas calidirosea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1303518.CCALI_00001";
/// let this_library_node_name2 = "1303518.CCALI_02931";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chthonomonas_calidirosea_node_name(this_library_node_name1));
/// assert!(is_valid_string_chthonomonas_calidirosea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chthonomonas_calidirosea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chthonomonas_calidirosea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1303518"]),
        None,
        Some("."),
        Some("CCALI_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces fulvissimus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1303692.SFUL_10";
/// let this_library_node_name2 = "1303692.SFUL_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_fulvissimus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_fulvissimus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_fulvissimus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_fulvissimus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1303692"]),
        None,
        Some("."),
        Some("SFUL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinisphaera hydrothermalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304275.C41B8_00005";
/// let this_library_node_name2 = "1304275.C41B8_19176";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinisphaera_hydrothermalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinisphaera_hydrothermalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinisphaera_hydrothermalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinisphaera_hydrothermalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304275"]),
        None,
        Some("."),
        Some("C41B8_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiaceae bacterium L21THD2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304284.L21TH_0001";
/// let this_library_node_name2 = "1304284.L21TH_2743";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiaceae_bacterium_l21thd2_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiaceae_bacterium_l21thd2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiaceae_bacterium_l21thd2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiaceae_bacterium_l21thd2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304284"]),
        None,
        Some("."),
        Some("L21TH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellulomonas sp. KRMCY2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304865.JAGF01000001_gene1";
/// let this_library_node_name2 = "1304865.JAGF01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellulomonas_sp_krmcy2_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellulomonas_sp_krmcy2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellulomonas_sp_krmcy2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellulomonas_sp_krmcy2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304865"]),
        None,
        Some("."),
        Some("JAGF01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. ASBs410 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304866.K413DRAFT_0002";
/// let this_library_node_name2 = "1304866.K413DRAFT_5479";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_asbs410_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_asbs410_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_asbs410_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_asbs410_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304866"]),
        None,
        Some("."),
        Some("K413DRAFT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio magneticus IFRC170 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304872.JAGC01000001_gene3950";
/// let this_library_node_name2 = "1304872.JAGC01000010_gene2235";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_magneticus_ifrc170_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_magneticus_ifrc170_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_magneticus_ifrc170_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_magneticus_ifrc170_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304872"]),
        None,
        Some("."),
        Some("JAGC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aminiphilus circumscriptus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304874.JAFY01000001_gene2555";
/// let this_library_node_name2 = "1304874.JAFY01000007_gene2554";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aminiphilus_circumscriptus_node_name(this_library_node_name1));
/// assert!(is_valid_string_aminiphilus_circumscriptus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aminiphilus_circumscriptus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aminiphilus_circumscriptus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304874"]),
        None,
        Some("."),
        Some("JAFY0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aminobacterium mobile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304875.JAFZ01000001_gene1000";
/// let this_library_node_name2 = "1304875.JAFZ01000005_gene401";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aminobacterium_mobile_node_name(this_library_node_name1));
/// assert!(is_valid_string_aminobacterium_mobile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aminobacterium_mobile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aminobacterium_mobile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304875"]),
        None,
        Some("."),
        Some("JAFZ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter nicotinovorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304876.AZVC01000001_gene1140";
/// let this_library_node_name2 = "1304876.AZVC01000037_gene2460";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_nicotinovorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_nicotinovorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_nicotinovorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_nicotinovorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304876"]),
        None,
        Some("."),
        Some("AZVC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium japonicum 22 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304877.KI519399_gene1910";
/// let this_library_node_name2 = "1304877.KI519401_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_japonicum_22_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_japonicum_22_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_japonicum_22_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_japonicum_22_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304877"]),
        None,
        Some("."),
        Some("KI519"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium japonicum in8p8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304878.AUGD01000001_gene1";
/// let this_library_node_name2 = "1304878.AUGD01000053_gene3129";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_japonicum_in8p8_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_japonicum_in8p8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_japonicum_in8p8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_japonicum_in8p8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304878"]),
        None,
        Some("."),
        Some("AUGD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caldicoprobacter oshimai nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304880.JAGB01000001_gene1";
/// let this_library_node_name2 = "1304880.JAGB01000006_gene2426";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caldicoprobacter_oshimai_node_name(this_library_node_name1));
/// assert!(is_valid_string_caldicoprobacter_oshimai_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caldicoprobacter_oshimai_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caldicoprobacter_oshimai_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304880"]),
        None,
        Some("."),
        Some("JAGB0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dechloromonas agitata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304883.KI912532_gene1";
/// let this_library_node_name2 = "1304883.KI912532_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dechloromonas_agitata_node_name(this_library_node_name1));
/// assert!(is_valid_string_dechloromonas_agitata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dechloromonas_agitata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dechloromonas_agitata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304883"]),
        None,
        Some("."),
        Some("KI912532_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulforegula conservatrix nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304885.AUEY01000001_gene3144";
/// let this_library_node_name2 = "1304885.AUEY01000184_gene3769";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulforegula_conservatrix_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulforegula_conservatrix_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulforegula_conservatrix_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulforegula_conservatrix_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304885"]),
        None,
        Some("."),
        Some("AUEY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geovibrio sp. L21AceBES nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1304888.ATWF01000001_gene1000";
/// let this_library_node_name2 = "1304888.ATWF01000002_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geovibrio_sp_l21acebes_node_name(this_library_node_name1));
/// assert!(is_valid_string_geovibrio_sp_l21acebes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geovibrio_sp_l21acebes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geovibrio_sp_l21acebes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1304888"]),
        None,
        Some("."),
        Some("ATWF0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium sp. KROCY2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1305732.JAGG01000001_gene1";
/// let this_library_node_name2 = "1305732.JAGG01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_sp_krocy2_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_sp_krocy2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_sp_krocy2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_sp_krocy2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1305732"]),
        None,
        Some("."),
        Some("JAGG01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanicola sp. HL35 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1305735.JAFT01000001_gene1";
/// let this_library_node_name2 = "1305735.JAFT01000008_gene3983";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanicola_sp_hl35_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanicola_sp_hl35_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanicola_sp_hl35_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanicola_sp_hl35_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1305735"]),
        None,
        Some("."),
        Some("JAFT0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Algoriphagus marincola HL49 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1305737.JAFX01000001_gene1";
/// let this_library_node_name2 = "1305737.JAFX01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_algoriphagus_marincola_hl49_node_name(this_library_node_name1));
/// assert!(is_valid_string_algoriphagus_marincola_hl49_node_name(this_library_node_name2));
/// assert!(!is_valid_string_algoriphagus_marincola_hl49_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_algoriphagus_marincola_hl49_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1305737"]),
        None,
        Some("."),
        Some("JAFX01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporosarcina sp. EUR3222 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1305836.AXVE01000001_gene2663";
/// let this_library_node_name2 = "1305836.AXVE01000019_gene2142";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporosarcina_sp_eur3222_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporosarcina_sp_eur3222_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporosarcina_sp_eur3222_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporosarcina_sp_eur3222_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1305836"]),
        None,
        Some("."),
        Some("AXVE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kineosporia aurantiaca nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1306174.JODP01000001_gene4617";
/// let this_library_node_name2 = "1306174.JODP01000066_gene64";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kineosporia_aurantiaca_node_name(this_library_node_name1));
/// assert!(is_valid_string_kineosporia_aurantiaca_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kineosporia_aurantiaca_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kineosporia_aurantiaca_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1306174"]),
        None,
        Some("."),
        Some("JODP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces thermolilacinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1306406.ASHX01000001_gene100";
/// let this_library_node_name2 = "1306406.ASHX01000015_gene7";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_thermolilacinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_thermolilacinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_thermolilacinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_thermolilacinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1306406"]),
        None,
        Some("."),
        Some("ASHX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING candidate division TM6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1306947.ARQD01000001_gene1000";
/// let this_library_node_name2 = "1306947.ARQD01000007_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_candidate_division_tm6_node_name(this_library_node_name1));
/// assert!(is_valid_string_candidate_division_tm6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_candidate_division_tm6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_candidate_division_tm6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1306947"]),
        None,
        Some("."),
        Some("ARQD0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. R1NS10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1306990.BARG01000001_gene1";
/// let this_library_node_name2 = "1306990.BARG01000178_gene10600";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_r1ns10_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_r1ns10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_r1ns10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_r1ns10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1306990"]),
        None,
        Some("."),
        Some("BARG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus firmus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1307436.PBF_00005";
/// let this_library_node_name2 = "1307436.PBF_24911";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_firmus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_firmus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_firmus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_firmus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1307436"]),
        None,
        Some("."),
        Some("PBF_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas agarivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1307437.J139_00005";
/// let this_library_node_name2 = "1307437.J139_20499";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_agarivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_agarivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_agarivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_agarivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1307437"]),
        None,
        Some("."),
        Some("J139_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio sp. L21SyrAB nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1307759.JOMJ01000001_gene2364";
/// let this_library_node_name2 = "1307759.JOMJ01000005_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_sp_l21syrab_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_sp_l21syrab_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_sp_l21syrab_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_sp_l21syrab_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1307759"]),
        None,
        Some("."),
        Some("JOMJ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirochaeta sp. L21RPulD2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1307761.L21SP2_0001";
/// let this_library_node_name2 = "1307761.L21SP2_3507";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirochaeta_sp_l21rpuld2_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirochaeta_sp_l21rpuld2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirochaeta_sp_l21rpuld2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirochaeta_sp_l21rpuld2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1307761"]),
        None,
        Some("."),
        Some("L21SP2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gluconobacter frateurii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1307834.BARL01000001_gene1";
/// let this_library_node_name2 = "1307834.BARL01000006_gene3094";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gluconobacter_frateurii_node_name(this_library_node_name1));
/// assert!(is_valid_string_gluconobacter_frateurii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gluconobacter_frateurii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gluconobacter_frateurii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1307834"]),
        None,
        Some("."),
        Some("BARL0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gracilibacillus halophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1308866.J416_00005";
/// let this_library_node_name2 = "1308866.J416_15702";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gracilibacillus_halophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_gracilibacillus_halophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gracilibacillus_halophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gracilibacillus_halophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1308866"]),
        None,
        Some("."),
        Some("J416_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. Br18 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1312954.KI914846_gene1637";
/// let this_library_node_name2 = "1312954.KI914901_gene273";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_br18_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_br18_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_br18_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_br18_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1312954"]),
        None,
        Some("."),
        Some("KI914"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. H14 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1312959.KI914621_gene2339";
/// let this_library_node_name2 = "1312959.KI914711_gene3284";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_h14_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_h14_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_h14_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_h14_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1312959"]),
        None,
        Some("."),
        Some("KI914"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ilumatobacter coccineus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1313172.YM304_00010";
/// let this_library_node_name2 = "1313172.YM304_42910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ilumatobacter_coccineus_node_name(this_library_node_name1));
/// assert!(is_valid_string_ilumatobacter_coccineus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ilumatobacter_coccineus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ilumatobacter_coccineus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1313172"]),
        None,
        Some("."),
        Some("YM304_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermocrinis sp. GBS nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1313265.JNIE01000001_gene236";
/// let this_library_node_name2 = "1313265.JNIE01000010_gene125";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermocrinis_sp_gbs_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermocrinis_sp_gbs_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermocrinis_sp_gbs_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermocrinis_sp_gbs_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1313265"]),
        None,
        Some("."),
        Some("JNIE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia coriaceae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1313292.BCO_0001407";
/// let this_library_node_name2 = "1313292.BCO_0900090";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_coriaceae_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_coriaceae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_coriaceae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_coriaceae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1313292"]),
        None,
        Some("."),
        Some("BCO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia anserina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1313293.BAN_0006500";
/// let this_library_node_name2 = "1313293.BAN_0900017";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_anserina_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_anserina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_anserina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_anserina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1313293"]),
        None,
        Some("."),
        Some("BAN_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia parkeri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1313294.BPA_0000900";
/// let this_library_node_name2 = "1313294.BPA_0900010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_parkeri_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_parkeri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_parkeri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_parkeri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1313294"]),
        None,
        Some("."),
        Some("BPA_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermonema rossianum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1313301.AUGC01000001_gene1395";
/// let this_library_node_name2 = "1313301.AUGC01000025_gene689";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermonema_rossianum_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermonema_rossianum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermonema_rossianum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermonema_rossianum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1313301"]),
        None,
        Some("."),
        Some("AUGC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chitinivibrio alkaliphilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1313304.CALK_0001";
/// let this_library_node_name2 = "1313304.CALK_2567";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chitinivibrio_alkaliphilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_chitinivibrio_alkaliphilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chitinivibrio_alkaliphilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chitinivibrio_alkaliphilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1313304"]),
        None,
        Some("."),
        Some("CALK_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aureispira sp. CCBQB1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1313421.JHBV01000001_gene502";
/// let this_library_node_name2 = "1313421.JHBV01000185_gene2321";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aureispira_sp_ccbqb1_node_name(this_library_node_name1));
/// assert!(is_valid_string_aureispira_sp_ccbqb1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aureispira_sp_ccbqb1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aureispira_sp_ccbqb1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1313421"]),
        None,
        Some("."),
        Some("JHBV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. HSISM1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1316408.HSISM1_1";
/// let this_library_node_name2 = "1316408.HSISM1_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_hsism1_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_hsism1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_hsism1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_hsism1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1316408"]),
        None,
        Some("."),
        Some("HSISM1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blattabacterium sp. Nci nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1316444.K645_1001";
/// let this_library_node_name2 = "1316444.K645_996";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blattabacterium_sp_nci_node_name(this_library_node_name1));
/// assert!(is_valid_string_blattabacterium_sp_nci_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blattabacterium_sp_nci_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blattabacterium_sp_nci_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1316444"]),
        None,
        Some("."),
        Some("K645_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas corrugata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1316927.ATKI01000002_gene4293";
/// let this_library_node_name2 = "1316927.ATKI01000157_gene1575";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_corrugata_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_corrugata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_corrugata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_corrugata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1316927"]),
        None,
        Some("."),
        Some("ATKI01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mannheimia haemolytica M42548 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1316932.MHH_c00010";
/// let this_library_node_name2 = "1316932.MHH_c28920";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mannheimia_haemolytica_m42548_node_name(this_library_node_name1));
/// assert!(is_valid_string_mannheimia_haemolytica_m42548_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mannheimia_haemolytica_m42548_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mannheimia_haemolytica_m42548_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1316932"]),
        None,
        Some("."),
        Some("MHH_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phaeospirillum fulvum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1316936.K678_00005";
/// let this_library_node_name2 = "1316936.K678_17716";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phaeospirillum_fulvum_node_name(this_library_node_name1));
/// assert!(is_valid_string_phaeospirillum_fulvum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phaeospirillum_fulvum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phaeospirillum_fulvum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1316936"]),
        None,
        Some("."),
        Some("K678_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseivivax sp. 22IIs10s nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1317118.ATO8_00005";
/// let this_library_node_name2 = "1317118.ATO8_21518";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseivivax_sp_22iis10s_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseivivax_sp_22iis10s_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseivivax_sp_22iis10s_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseivivax_sp_22iis10s_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1317118"]),
        None,
        Some("."),
        Some("ATO8_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquimarina sp. 22IIS11z7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1317122.ATO12_00005";
/// let this_library_node_name2 = "1317122.ATO12_25295";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquimarina_sp_22iis11z7_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquimarina_sp_22iis11z7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquimarina_sp_22iis11z7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquimarina_sp_22iis11z7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1317122"]),
        None,
        Some("."),
        Some("ATO12_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioclava sp. 13D2W2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1317124.DW2_00005";
/// let this_library_node_name2 = "1317124.DW2_18999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioclava_sp_13d2w2_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioclava_sp_13d2w2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioclava_sp_13d2w2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioclava_sp_13d2w2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1317124"]),
        None,
        Some("."),
        Some("DW2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycoplasma girerdii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1318617.MGM1_0010";
/// let this_library_node_name2 = "1318617.MGM1_6110";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycoplasma_girerdii_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycoplasma_girerdii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycoplasma_girerdii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycoplasma_girerdii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1318617"]),
        None,
        Some("."),
        Some("MGM1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter lipolyticus SM19 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1318628.MARLIPOL_00005";
/// let this_library_node_name2 = "1318628.MARLIPOL_18328";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_lipolyticus_sm19_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_lipolyticus_sm19_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_lipolyticus_sm19_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_lipolyticus_sm19_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1318628"]),
        None,
        Some("."),
        Some("MARLIPOL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cetobacterium somerae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1319815.HMPREF0202_00001";
/// let this_library_node_name2 = "1319815.HMPREF0202_03015";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cetobacterium_somerae_node_name(this_library_node_name1));
/// assert!(is_valid_string_cetobacterium_somerae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cetobacterium_somerae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cetobacterium_somerae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1319815"]),
        None,
        Some("."),
        Some("HMPREF0202_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium sp. NBIMCP2C3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1320556.AVBP01000001_gene4173";
/// let this_library_node_name2 = "1320556.AVBP01000044_gene3634";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_sp_nbimcp2c3_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_sp_nbimcp2c3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_sp_nbimcp2c3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_sp_nbimcp2c3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1320556"]),
        None,
        Some("."),
        Some("AVBP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus suis EA183292 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321372.AQQB01000001_gene1360";
/// let this_library_node_name2 = "1321372.AQQB01000089_gene890";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_suis_ea183292_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_suis_ea183292_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_suis_ea183292_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_suis_ea183292_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321372"]),
        None,
        Some("."),
        Some("AQQB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atopobium sp. F0209 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321773.HMPREF9069_00001";
/// let this_library_node_name2 = "1321773.HMPREF9069_01965";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atopobium_sp_f0209_node_name(this_library_node_name1));
/// assert!(is_valid_string_atopobium_sp_f0209_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atopobium_sp_f0209_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atopobium_sp_f0209_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321773"]),
        None,
        Some("."),
        Some("HMPREF9069_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptotrichia sp. F0581 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321774.HMPREF9108_00001";
/// let this_library_node_name2 = "1321774.HMPREF9108_02403";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptotrichia_sp_f0581_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptotrichia_sp_f0581_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptotrichia_sp_f0581_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptotrichia_sp_f0581_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321774"]),
        None,
        Some("."),
        Some("HMPREF9108_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomyces sp. F0311 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321775.HMPREF1980_00001";
/// let this_library_node_name2 = "1321775.HMPREF1980_02467";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomyces_sp_f0311_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomyces_sp_f0311_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomyces_sp_f0311_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomyces_sp_f0311_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321775"]),
        None,
        Some("."),
        Some("HMPREF1980_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium F0540 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321778.HMPREF1982_00001";
/// let this_library_node_name2 = "1321778.HMPREF1982_04736";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_f0540_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_f0540_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_f0540_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_f0540_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321778"]),
        None,
        Some("."),
        Some("HMPREF1982_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptotrichia sp. W9775 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321779.HMPREF1984_00001";
/// let this_library_node_name2 = "1321779.HMPREF1984_02300";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptotrichia_sp_w9775_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptotrichia_sp_w9775_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptotrichia_sp_w9775_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptotrichia_sp_w9775_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321779"]),
        None,
        Some("."),
        Some("HMPREF1984_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mitsuokella sp. W9106 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321781.HMPREF1985_00001";
/// let this_library_node_name2 = "1321781.HMPREF1985_02363";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mitsuokella_sp_w9106_node_name(this_library_node_name1));
/// assert!(is_valid_string_mitsuokella_sp_w9106_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mitsuokella_sp_w9106_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mitsuokella_sp_w9106_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321781"]),
        None,
        Some("."),
        Some("HMPREF1985_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oribacterium sp. F0263 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321782.HMPREF1986_00001";
/// let this_library_node_name2 = "1321782.HMPREF1986_02886";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oribacterium_sp_f0263_node_name(this_library_node_name1));
/// assert!(is_valid_string_oribacterium_sp_f0263_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oribacterium_sp_f0263_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oribacterium_sp_f0263_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321782"]),
        None,
        Some("."),
        Some("HMPREF1986_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptostreptococcaceae bacterium W5053 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321784.HMPREF1987_00001";
/// let this_library_node_name2 = "1321784.HMPREF1987_02372";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptostreptococcaceae_bacterium_w5053_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptostreptococcaceae_bacterium_w5053_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptostreptococcaceae_bacterium_w5053_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptostreptococcaceae_bacterium_w5053_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321784"]),
        None,
        Some("."),
        Some("HMPREF1987_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas sp. F0426 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321786.HMPREF1992_00001";
/// let this_library_node_name2 = "1321786.HMPREF1992_02360";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_sp_f0426_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_sp_f0426_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_sp_f0426_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_sp_f0426_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321786"]),
        None,
        Some("."),
        Some("HMPREF1992_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium brachy nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321814.HMPREF9089_00001";
/// let this_library_node_name2 = "1321814.HMPREF9089_01520";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_brachy_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_brachy_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_brachy_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_brachy_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321814"]),
        None,
        Some("."),
        Some("HMPREF9089_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema lecithinolyticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321815.HMPREF9193_00001";
/// let this_library_node_name2 = "1321815.HMPREF9193_02224";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_lecithinolyticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_lecithinolyticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_lecithinolyticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_lecithinolyticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321815"]),
        None,
        Some("."),
        Some("HMPREF9193_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemella bergeriae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1321820.HMPREF1983_00001";
/// let this_library_node_name2 = "1321820.HMPREF1983_01581";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemella_bergeriae_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemella_bergeriae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemella_bergeriae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemella_bergeriae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1321820"]),
        None,
        Some("."),
        Some("HMPREF1983_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfovibrio piezophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1322246.BN4_10001";
/// let this_library_node_name2 = "1322246.BN4_20532";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfovibrio_piezophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfovibrio_piezophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfovibrio_piezophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfovibrio_piezophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1322246"]),
        None,
        Some("."),
        Some("BN4_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus defluvii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1323361.JPOC01000001_gene3561";
/// let this_library_node_name2 = "1323361.JPOC01000265_gene3801";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_defluvii_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_defluvii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_defluvii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_defluvii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1323361"]),
        None,
        Some("."),
        Some("JPOC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas pelagia nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1323663.AROI01000001_gene1000";
/// let this_library_node_name2 = "1323663.AROI01000081_gene1438";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_pelagia_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_pelagia_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_pelagia_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_pelagia_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1323663"]),
        None,
        Some("."),
        Some("AROI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halobonum tyrrellensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1324957.K933_00005";
/// let this_library_node_name2 = "1324957.K933_17397";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halobonum_tyrrellensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_halobonum_tyrrellensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halobonum_tyrrellensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halobonum_tyrrellensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1324957"]),
        None,
        Some("."),
        Some("K933_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter fennelliae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1325130.HFN_0001";
/// let this_library_node_name2 = "1325130.HFN_2467";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_fennelliae_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_fennelliae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_fennelliae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_fennelliae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1325130"]),
        None,
        Some("."),
        Some("HFN_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Catenovulum agarivorans DS2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1328313.DS2_00005";
/// let this_library_node_name2 = "1328313.DS2_19487";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_catenovulum_agarivorans_ds2_node_name(this_library_node_name1));
/// assert!(is_valid_string_catenovulum_agarivorans_ds2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_catenovulum_agarivorans_ds2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_catenovulum_agarivorans_ds2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1328313"]),
        None,
        Some("."),
        Some("DS2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Weissella oryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1329250.WOSG25_010010";
/// let this_library_node_name2 = "1329250.WOSG25_700010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_weissella_oryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_weissella_oryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_weissella_oryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_weissella_oryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1329250"]),
        None,
        Some("."),
        Some("WOSG25_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermoactinomyces daqus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1329516.JPST01000001_gene1000";
/// let this_library_node_name2 = "1329516.JPST01000083_gene2109";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermoactinomyces_daqus_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermoactinomyces_daqus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermoactinomyces_daqus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermoactinomyces_daqus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1329516"]),
        None,
        Some("."),
        Some("JPST010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus caliditerrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1330700.JQNC01000001_gene2110";
/// let this_library_node_name2 = "1330700.JQNC01000004_gene8";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_caliditerrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_caliditerrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_caliditerrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_caliditerrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1330700"]),
        None,
        Some("."),
        Some("JQNC0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium lactosutens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1331060.RLDS_00010";
/// let this_library_node_name2 = "1331060.RLDS_27305";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_lactosutens_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_lactosutens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_lactosutens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_lactosutens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1331060"]),
        None,
        Some("."),
        Some("RLDS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter haemolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1331660.L313_0001";
/// let this_library_node_name2 = "1331660.L313_3156";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_haemolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_haemolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_haemolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_haemolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1331660"]),
        None,
        Some("."),
        Some("L313_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia fonticola AUAP2C nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1332071.L581_0001";
/// let this_library_node_name2 = "1332071.L581_4532";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_fonticola_auap2c_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_fonticola_auap2c_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_fonticola_auap2c_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_fonticola_auap2c_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1332071"]),
        None,
        Some("."),
        Some("L581_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas haloplanktis TB64 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1333507.AUTQ01000001_gene1043";
/// let this_library_node_name2 = "1333507.AUTQ01000275_gene2045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_haloplanktis_tb64_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_haloplanktis_tb64_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_haloplanktis_tb64_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_haloplanktis_tb64_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1333507"]),
        None,
        Some("."),
        Some("AUTQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Salinarchaeum sp. HarchtBsk1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1333523.L593_00005";
/// let this_library_node_name2 = "1333523.L593_15170";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_salinarchaeum_sp_harchtbsk1_node_name(this_library_node_name1));
/// assert!(is_valid_string_salinarchaeum_sp_harchtbsk1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_salinarchaeum_sp_harchtbsk1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_salinarchaeum_sp_harchtbsk1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1333523"]),
        None,
        Some("."),
        Some("L593_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas stutzeri MF28 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1333856.L686_00005";
/// let this_library_node_name2 = "1333856.L686_23180";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_stutzeri_mf28_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_stutzeri_mf28_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_stutzeri_mf28_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_stutzeri_mf28_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1333856"]),
        None,
        Some("."),
        Some("L686_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING alpha proteobacterium MA2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1333998.M2A_0001";
/// let this_library_node_name2 = "1333998.M2A_3401";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alpha_proteobacterium_ma2_node_name(this_library_node_name1));
/// assert!(is_valid_string_alpha_proteobacterium_ma2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alpha_proteobacterium_ma2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alpha_proteobacterium_ma2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1333998"]),
        None,
        Some("."),
        Some("M2A_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kurthia huakuii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1334046.AYTB01000001_gene1788";
/// let this_library_node_name2 = "1334046.AYTB01000056_gene24";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kurthia_huakuii_node_name(this_library_node_name1));
/// assert!(is_valid_string_kurthia_huakuii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kurthia_huakuii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kurthia_huakuii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1334046"]),
        None,
        Some("."),
        Some("AYTB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spiribacter sp. UAHSP71 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1335757.SPICUR_00005";
/// let this_library_node_name2 = "1335757.SPICUR_09570";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spiribacter_sp_uahsp71_node_name(this_library_node_name1));
/// assert!(is_valid_string_spiribacter_sp_uahsp71_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spiribacter_sp_uahsp71_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spiribacter_sp_uahsp71_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1335757"]),
        None,
        Some("."),
        Some("SPICUR_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium sp. YL23 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1335760.ASTG01000001_gene2856";
/// let this_library_node_name2 = "1335760.ASTG01000067_gene78";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_sp_yl23_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_sp_yl23_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_sp_yl23_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_sp_yl23_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1335760"]),
        None,
        Some("."),
        Some("ASTG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseomonas gilardii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1336208.JADY01000001_gene1000";
/// let this_library_node_name2 = "1336208.JADY01000054_gene4050";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseomonas_gilardii_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseomonas_gilardii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseomonas_gilardii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseomonas_gilardii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1336208"]),
        None,
        Some("."),
        Some("JADY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella waksmanii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1336233.JAEH01000001_gene634";
/// let this_library_node_name2 = "1336233.JAEH01000088_gene3414";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_waksmanii_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_waksmanii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_waksmanii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_waksmanii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1336233"]),
        None,
        Some("."),
        Some("JAEH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atopobacter phocae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1336234.JAGN01000001_gene1155";
/// let this_library_node_name2 = "1336234.JAGN01000082_gene1255";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atopobacter_phocae_node_name(this_library_node_name1));
/// assert!(is_valid_string_atopobacter_phocae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atopobacter_phocae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atopobacter_phocae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1336234"]),
        None,
        Some("."),
        Some("JAGN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium selenitireducens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1336235.JAEG01000001_gene1775";
/// let this_library_node_name2 = "1336235.JAEG01000032_gene4534";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_selenitireducens_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_selenitireducens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_selenitireducens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_selenitireducens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1336235"]),
        None,
        Some("."),
        Some("JAEG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas flectens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1336237.JAEE01000001_gene1455";
/// let this_library_node_name2 = "1336237.JAEE01000028_gene1099";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_flectens_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_flectens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_flectens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_flectens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1336237"]),
        None,
        Some("."),
        Some("JAEE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium xylanophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1336241.JAEB01000001_gene1";
/// let this_library_node_name2 = "1336241.JAEB01000053_gene2072";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_xylanophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_xylanophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_xylanophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_xylanophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1336241"]),
        None,
        Some("."),
        Some("JAEB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microvirga flocculans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1336243.JAEA01000001_gene1610";
/// let this_library_node_name2 = "1336243.JAEA01000029_gene1609";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microvirga_flocculans_node_name(this_library_node_name1));
/// assert!(is_valid_string_microvirga_flocculans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microvirga_flocculans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microvirga_flocculans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1336243"]),
        None,
        Some("."),
        Some("JAEA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carnimonas nigrificans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1336245.JAGO01000001_gene1053";
/// let this_library_node_name2 = "1336245.JAGO01000018_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carnimonas_nigrificans_node_name(this_library_node_name1));
/// assert!(is_valid_string_carnimonas_nigrificans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carnimonas_nigrificans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carnimonas_nigrificans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1336245"]),
        None,
        Some("."),
        Some("JAGO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium larrymoorei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1336249.JADW01000001_gene1672";
/// let this_library_node_name2 = "1336249.JADW01000075_gene491";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_larrymoorei_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_larrymoorei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_larrymoorei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_larrymoorei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1336249"]),
        None,
        Some("."),
        Some("JADW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polaribacter sp. Hel13349 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1336803.PHEL49_0001";
/// let this_library_node_name2 = "1336803.PHEL49_2668";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polaribacter_sp_hel13349_node_name(this_library_node_name1));
/// assert!(is_valid_string_polaribacter_sp_hel13349_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polaribacter_sp_hel13349_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polaribacter_sp_hel13349_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1336803"]),
        None,
        Some("."),
        Some("PHEL49_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Loktanella cinnabarina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1337093.MBE-LCI_0001";
/// let this_library_node_name2 = "1337093.MBE-LCI_3802";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_loktanella_cinnabarina_node_name(this_library_node_name1));
/// assert!(is_valid_string_loktanella_cinnabarina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_loktanella_cinnabarina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_loktanella_cinnabarina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1337093"]),
        None,
        Some("."),
        Some("MBE-LCI_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Calothrix sp. 3363 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1337936.IJ00_00010";
/// let this_library_node_name2 = "1337936.IJ00_28250";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_calothrix_sp_3363_node_name(this_library_node_name1));
/// assert!(is_valid_string_calothrix_sp_3363_node_name(this_library_node_name2));
/// assert!(!is_valid_string_calothrix_sp_3363_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_calothrix_sp_3363_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1337936"]),
        None,
        Some("."),
        Some("IJ00_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Elizabethkingia anophelis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1338011.BD94_0001";
/// let this_library_node_name2 = "1338011.BD94_4076";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_elizabethkingia_anophelis_node_name(this_library_node_name1));
/// assert!(is_valid_string_elizabethkingia_anophelis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_elizabethkingia_anophelis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_elizabethkingia_anophelis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1338011"]),
        None,
        Some("."),
        Some("BD94_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. UNC438CL73TsuS30 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1340434.AXVA01000001_gene1114";
/// let this_library_node_name2 = "1340434.AXVA01000050_gene4248";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_unc438cl73tsus30_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_unc438cl73tsus30_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_unc438cl73tsus30_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_unc438cl73tsus30_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1340434"]),
        None,
        Some("."),
        Some("AXVA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bryobacter aggregatus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1340493.JNIF01000001_gene1211";
/// let this_library_node_name2 = "1340493.JNIF01000004_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bryobacter_aggregatus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bryobacter_aggregatus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bryobacter_aggregatus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bryobacter_aggregatus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1340493"]),
        None,
        Some("."),
        Some("JNIF0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Laceyella sacchari nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1341151.ASZU01000001_gene672";
/// let this_library_node_name2 = "1341151.ASZU01000042_gene2725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_laceyella_sacchari_node_name(this_library_node_name1));
/// assert!(is_valid_string_laceyella_sacchari_node_name(this_library_node_name2));
/// assert!(!is_valid_string_laceyella_sacchari_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_laceyella_sacchari_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1341151"]),
        None,
        Some("."),
        Some("ASZU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium saliperosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1341155.FSS13T_00010";
/// let this_library_node_name2 = "1341155.FSS13T_27470";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_saliperosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_saliperosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_saliperosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_saliperosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1341155"]),
        None,
        Some("."),
        Some("FSS13T_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus flavefaciens 007c nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1341157.RF007C_00025";
/// let this_library_node_name2 = "1341157.RF007C_16465";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_flavefaciens_007c_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_flavefaciens_007c_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_flavefaciens_007c_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_flavefaciens_007c_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1341157"]),
        None,
        Some("."),
        Some("RF007C_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium limnosediminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1341181.FLJC2902T_00010";
/// let this_library_node_name2 = "1341181.FLJC2902T_32550";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_limnosediminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_limnosediminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_limnosediminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_limnosediminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1341181"]),
        None,
        Some("."),
        Some("FLJC2902T_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium septicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1341646.CBMO010000001_gene1591";
/// let this_library_node_name2 = "1341646.CBMO010000164_gene4441";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_septicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_septicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_septicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_septicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1341646"]),
        None,
        Some("."),
        Some("CBMO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter indicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1341679.P253_00006";
/// let this_library_node_name2 = "1341679.P253_03104";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_indicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_indicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_indicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_indicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1341679"]),
        None,
        Some("."),
        Some("P253_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium bombi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1341695.BBOMB_0001";
/// let this_library_node_name2 = "1341695.BBOMB_2001";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_bombi_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_bombi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_bombi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_bombi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1341695"]),
        None,
        Some("."),
        Some("BBOMB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfitobacter sp. MM124 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1342299.Z947_1";
/// let this_library_node_name2 = "1342299.Z947_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfitobacter_sp_mm124_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfitobacter_sp_mm124_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfitobacter_sp_mm124_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfitobacter_sp_mm124_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1342299"]),
        None,
        Some("."),
        Some("Z947_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfitobacter sp. NB77 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1342301.JASD01000001_gene254";
/// let this_library_node_name2 = "1342301.JASD01000008_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfitobacter_sp_nb77_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfitobacter_sp_nb77_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfitobacter_sp_nb77_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfitobacter_sp_nb77_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1342301"]),
        None,
        Some("."),
        Some("JASD0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfitobacter sp. NB68 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1342302.JASC01000001_gene208";
/// let this_library_node_name2 = "1342302.JASC01000014_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfitobacter_sp_nb68_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfitobacter_sp_nb68_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfitobacter_sp_nb68_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfitobacter_sp_nb68_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1342302"]),
        None,
        Some("."),
        Some("JASC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharibacter sp. AM169 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1343158.SACS_0001";
/// let this_library_node_name2 = "1343158.SACS_1877";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharibacter_sp_am169_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharibacter_sp_am169_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharibacter_sp_am169_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharibacter_sp_am169_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1343158"]),
        None,
        Some("."),
        Some("SACS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Palaeococcus pacificus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1343739.PAP_00005";
/// let this_library_node_name2 = "1343739.PAP_10280";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_palaeococcus_pacificus_node_name(this_library_node_name1));
/// assert!(is_valid_string_palaeococcus_pacificus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_palaeococcus_pacificus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_palaeococcus_pacificus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1343739"]),
        None,
        Some("."),
        Some("PAP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces rapamycinicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1343740.M271_00005";
/// let this_library_node_name2 = "1343740.M271_50905";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_rapamycinicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_rapamycinicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_rapamycinicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_rapamycinicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1343740"]),
        None,
        Some("."),
        Some("M271_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tatumella sp. NML063099 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1344012.ATMI01000001_gene1151";
/// let this_library_node_name2 = "1344012.ATMI01000056_gene1824";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tatumella_sp_nml063099_node_name(this_library_node_name1));
/// assert!(is_valid_string_tatumella_sp_nml063099_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tatumella_sp_nml063099_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tatumella_sp_nml063099_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1344012"]),
        None,
        Some("."),
        Some("ATMI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Exiguobacterium pavilionensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1345023.M467_00010";
/// let this_library_node_name2 = "1345023.M467_15710";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_exiguobacterium_pavilionensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_exiguobacterium_pavilionensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_exiguobacterium_pavilionensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_exiguobacterium_pavilionensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1345023"]),
        None,
        Some("."),
        Some("M467_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter pylori SA213A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1345592.CBOM010000001_gene1";
/// let this_library_node_name2 = "1345592.CBOM010000085_gene1544";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_pylori_sa213a_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_pylori_sa213a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_pylori_sa213a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_pylori_sa213a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1345592"]),
        None,
        Some("."),
        Some("CBOM0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium saccharobutylicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1345695.CLSA_c00010";
/// let this_library_node_name2 = "1345695.CLSA_c45520";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_saccharobutylicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_saccharobutylicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_saccharobutylicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_saccharobutylicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1345695"]),
        None,
        Some("."),
        Some("CLSA_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacillus sp. JF8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1345697.M493_00210";
/// let this_library_node_name2 = "1345697.M493_18497";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacillus_sp_jf8_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacillus_sp_jf8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacillus_sp_jf8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacillus_sp_jf8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1345697"]),
        None,
        Some("."),
        Some("M493_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobacterium paucimobilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1346330.M472_00040";
/// let this_library_node_name2 = "1346330.M472_22255";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobacterium_paucimobilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobacterium_paucimobilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobacterium_paucimobilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobacterium_paucimobilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1346330"]),
        None,
        Some("."),
        Some("M472_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium ummariense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1346791.M529_00010";
/// let this_library_node_name2 = "1346791.M529_23940";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_ummariense_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_ummariense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_ummariense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_ummariense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1346791"]),
        None,
        Some("."),
        Some("M529_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. EB01 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1347086.CCBA010000001_gene1957";
/// let this_library_node_name2 = "1347086.CCBA010000046_gene2484";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_eb01_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_eb01_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_eb01_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_eb01_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1347086"]),
        None,
        Some("."),
        Some("CCBA0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paucisalibacillus sp. EB02 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1347087.CBYO010000001_gene1";
/// let this_library_node_name2 = "1347087.CBYO010000023_gene3968";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paucisalibacillus_sp_eb02_node_name(this_library_node_name1));
/// assert!(is_valid_string_paucisalibacillus_sp_eb02_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paucisalibacillus_sp_eb02_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paucisalibacillus_sp_eb02_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1347087"]),
        None,
        Some("."),
        Some("CBYO0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Formosa agariphila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1347342.BN863_10";
/// let this_library_node_name2 = "1347342.BN863_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_formosa_agariphila_node_name(this_library_node_name1));
/// assert!(is_valid_string_formosa_agariphila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_formosa_agariphila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_formosa_agariphila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1347342"]),
        None,
        Some("."),
        Some("BN863_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. FF3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1347368.HG964403_gene3897";
/// let this_library_node_name2 = "1347368.HG964419_gene7792";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_ff3_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_ff3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_ff3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_ff3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1347368"]),
        None,
        Some("."),
        Some("HG9644"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. FF4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1347369.CCAD010000001_gene2294";
/// let this_library_node_name2 = "1347369.CCAD010000094_gene2275";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_ff4_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_ff4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_ff4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_ff4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1347369"]),
        None,
        Some("."),
        Some("CCAD0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerosalibacter sp. ND1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1347392.CCEZ01000001_gene1258";
/// let this_library_node_name2 = "1347392.CCEZ01000081_gene3253";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerosalibacter_sp_nd1_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerosalibacter_sp_nd1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerosalibacter_sp_nd1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerosalibacter_sp_nd1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1347392"]),
        None,
        Some("."),
        Some("CCEZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroidaceae bacterium MS4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1347393.HG726019_gene7565";
/// let this_library_node_name2 = "1347393.HG726036_gene7503";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroidaceae_bacterium_ms4_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroidaceae_bacterium_ms4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroidaceae_bacterium_ms4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroidaceae_bacterium_ms4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1347393"]),
        None,
        Some("."),
        Some("HG7260"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudoalteromonas sp. OCN003 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1348114.OM33_00035";
/// let this_library_node_name2 = "1348114.OM33_21870";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudoalteromonas_sp_ocn003_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudoalteromonas_sp_ocn003_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudoalteromonas_sp_ocn003_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudoalteromonas_sp_ocn003_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1348114"]),
        None,
        Some("."),
        Some("OM33_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leifsonia rubra nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1348338.ADILRU_0001";
/// let this_library_node_name2 = "1348338.ADILRU_2723";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leifsonia_rubra_node_name(this_library_node_name1));
/// assert!(is_valid_string_leifsonia_rubra_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leifsonia_rubra_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leifsonia_rubra_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1348338"]),
        None,
        Some("."),
        Some("ADILRU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellulophaga baltica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1348583.ATLH01000001_gene3552";
/// let this_library_node_name2 = "1348583.ATLH01000041_gene248";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellulophaga_baltica_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellulophaga_baltica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellulophaga_baltica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellulophaga_baltica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1348583"]),
        None,
        Some("."),
        Some("ATLH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio diazotrophicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1348635.BBJY01000001_gene2333";
/// let this_library_node_name2 = "1348635.BBJY01000054_gene1972";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_diazotrophicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_diazotrophicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_diazotrophicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_diazotrophicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1348635"]),
        None,
        Some("."),
        Some("BBJY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thauera terpenica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1348657.M622_00005";
/// let this_library_node_name2 = "1348657.M622_19670";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thauera_terpenica_node_name(this_library_node_name1));
/// assert!(is_valid_string_thauera_terpenica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thauera_terpenica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thauera_terpenica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1348657"]),
        None,
        Some("."),
        Some("M622_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium argentoratense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1348662.CARG_00005";
/// let this_library_node_name2 = "1348662.CARG_09695";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_argentoratense_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_argentoratense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_argentoratense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_argentoratense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1348662"]),
        None,
        Some("."),
        Some("CARG_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kitasatospora cheerisanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1348663.KCH_00010";
/// let this_library_node_name2 = "1348663.KCH_78100";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kitasatospora_cheerisanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_kitasatospora_cheerisanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kitasatospora_cheerisanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kitasatospora_cheerisanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1348663"]),
        None,
        Some("."),
        Some("KCH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus megaterium MSP201 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1348908.KI518578_gene524";
/// let this_library_node_name2 = "1348908.KI518655_gene1545";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_megaterium_msp201_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_megaterium_msp201_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_megaterium_msp201_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_megaterium_msp201_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1348908"]),
        None,
        Some("."),
        Some("KI518"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Janthinobacterium agaricidamnosum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1349767.GJA_1";
/// let this_library_node_name2 = "1349767.GJA_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_janthinobacterium_agaricidamnosum_node_name(this_library_node_name1));
/// assert!(is_valid_string_janthinobacterium_agaricidamnosum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_janthinobacterium_agaricidamnosum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_janthinobacterium_agaricidamnosum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1349767"]),
        None,
        Some("."),
        Some("GJA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tenacibaculum maritimum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1349785.BAUG01000001_gene1";
/// let this_library_node_name2 = "1349785.BAUG01000159_gene2911";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tenacibaculum_maritimum_node_name(this_library_node_name1));
/// assert!(is_valid_string_tenacibaculum_maritimum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tenacibaculum_maritimum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tenacibaculum_maritimum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1349785"]),
        None,
        Some("."),
        Some("BAUG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. AKYN10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1349820.M707_00010";
/// let this_library_node_name2 = "1349820.M707_23435";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_akyn10_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_akyn10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_akyn10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_akyn10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1349820"]),
        None,
        Some("."),
        Some("M707_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Coprobacter fastidiosus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1349822.NSB1T_00005";
/// let this_library_node_name2 = "1349822.NSB1T_14515";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_coprobacter_fastidiosus_node_name(this_library_node_name1));
/// assert!(is_valid_string_coprobacter_fastidiosus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_coprobacter_fastidiosus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_coprobacter_fastidiosus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1349822"]),
        None,
        Some("."),
        Some("NSB1T_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces niveus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1352941.M877_00005";
/// let this_library_node_name2 = "1352941.M877_40145";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_niveus_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_niveus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_niveus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_niveus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1352941"]),
        None,
        Some("."),
        Some("M877_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Olleya marilimosa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1353276.JADR01000001_gene1";
/// let this_library_node_name2 = "1353276.JADR01000028_gene2992";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_olleya_marilimosa_node_name(this_library_node_name1));
/// assert!(is_valid_string_olleya_marilimosa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_olleya_marilimosa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_olleya_marilimosa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1353276"]),
        None,
        Some("."),
        Some("JADR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioclava sp. DT234 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1353528.DT23_00005";
/// let this_library_node_name2 = "1353528.DT23_19010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioclava_sp_dt234_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioclava_sp_dt234_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioclava_sp_dt234_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioclava_sp_dt234_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1353528"]),
        None,
        Some("."),
        Some("DT23_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteriovorax sp. BSW11IV nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1353529.M899_0001";
/// let this_library_node_name2 = "1353529.M899_3521";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteriovorax_sp_bsw11iv_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteriovorax_sp_bsw11iv_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteriovorax_sp_bsw11iv_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteriovorax_sp_bsw11iv_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1353529"]),
        None,
        Some("."),
        Some("M899_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ensifer sp. TW10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1353531.AZNX01000001_gene1320";
/// let this_library_node_name2 = "1353531.AZNX01000059_gene4131";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ensifer_sp_tw10_node_name(this_library_node_name1));
/// assert!(is_valid_string_ensifer_sp_tw10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ensifer_sp_tw10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ensifer_sp_tw10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1353531"]),
        None,
        Some("."),
        Some("AZNX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioclava pacifica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1353537.TP2_00005";
/// let this_library_node_name2 = "1353537.TP2_18210";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioclava_pacifica_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioclava_pacifica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioclava_pacifica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioclava_pacifica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1353537"]),
        None,
        Some("."),
        Some("TP2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptoniphilus sp. ChDC nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1354300.AUQY01000001_gene1334";
/// let this_library_node_name2 = "1354300.AUQY01000005_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptoniphilus_sp_chdc_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptoniphilus_sp_chdc_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptoniphilus_sp_chdc_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptoniphilus_sp_chdc_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1354300"]),
        None,
        Some("."),
        Some("AUQY0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychrobacter aquaticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1354303.M917_0001";
/// let this_library_node_name2 = "1354303.M917_2860";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychrobacter_aquaticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychrobacter_aquaticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychrobacter_aquaticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychrobacter_aquaticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1354303"]),
        None,
        Some("."),
        Some("M917_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cardinium endosymbiont cBtQ1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1354314.CHV_a0003";
/// let this_library_node_name2 = "1354314.CHV_k0003";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cardinium_endosymbiont_cbtq1_node_name(this_library_node_name1));
/// assert!(is_valid_string_cardinium_endosymbiont_cbtq1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cardinium_endosymbiont_cbtq1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cardinium_endosymbiont_cbtq1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1354314"]),
        None,
        Some("."),
        Some("CHV_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseovarius sp. MCTG156 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1354722.JQLS01000001_gene4602";
/// let this_library_node_name2 = "1354722.JQLS01000008_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseovarius_sp_mctg156_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseovarius_sp_mctg156_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseovarius_sp_mctg156_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseovarius_sp_mctg156_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1354722"]),
        None,
        Some("."),
        Some("JQLS0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arcobacter sp. AF1028 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1355368.JART01000001_gene667";
/// let this_library_node_name2 = "1355368.JART01000047_gene389";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arcobacter_sp_af1028_node_name(this_library_node_name1));
/// assert!(is_valid_string_arcobacter_sp_af1028_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arcobacter_sp_af1028_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arcobacter_sp_af1028_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1355368"]),
        None,
        Some("."),
        Some("JART010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arcobacter sp. AF1440 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1355374.JARU01000001_gene100";
/// let this_library_node_name2 = "1355374.JARU01000029_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arcobacter_sp_af1440_node_name(this_library_node_name1));
/// assert!(is_valid_string_arcobacter_sp_af1440_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arcobacter_sp_af1440_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arcobacter_sp_af1440_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1355374"]),
        None,
        Some("."),
        Some("JARU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hymenobacter sp. APR13 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1356852.N008_00005";
/// let this_library_node_name2 = "1356852.N008_21830";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hymenobacter_sp_apr13_node_name(this_library_node_name1));
/// assert!(is_valid_string_hymenobacter_sp_apr13_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hymenobacter_sp_apr13_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hymenobacter_sp_apr13_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1356852"]),
        None,
        Some("."),
        Some("N008_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alicyclobacillus acidoterrestris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1356854.N007_00005";
/// let this_library_node_name2 = "1356854.N007_21580";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alicyclobacillus_acidoterrestris_node_name(this_library_node_name1));
/// assert!(is_valid_string_alicyclobacillus_acidoterrestris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alicyclobacillus_acidoterrestris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alicyclobacillus_acidoterrestris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1356854"]),
        None,
        Some("."),
        Some("N007_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas syringae CC1417 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1357272.AVEO02000001_gene3327";
/// let this_library_node_name2 = "1357272.AVEO02000210_gene3326";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_syringae_cc1417_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_syringae_cc1417_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_syringae_cc1417_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_syringae_cc1417_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1357272"]),
        None,
        Some("."),
        Some("AVEO02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas syringae CC1513 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1357275.AVEL02000001_gene3484";
/// let this_library_node_name2 = "1357275.AVEL02000164_gene577";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_syringae_cc1513_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_syringae_cc1513_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_syringae_cc1513_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_syringae_cc1513_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1357275"]),
        None,
        Some("."),
        Some("AVEL02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas syringae CC1557 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1357279.N018_00010";
/// let this_library_node_name2 = "1357279.N018_26200";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_syringae_cc1557_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_syringae_cc1557_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_syringae_cc1557_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_syringae_cc1557_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1357279"]),
        None,
        Some("."),
        Some("N018_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter canis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1357399.HMPREF2087_00005";
/// let this_library_node_name2 = "1357399.HMPREF2087_01843";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_canis_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_canis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_canis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_canis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1357399"]),
        None,
        Some("."),
        Some("HMPREF2087_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter macacae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1357400.HMPREF2086_00001";
/// let this_library_node_name2 = "1357400.HMPREF2086_01991";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_macacae_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_macacae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_macacae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_macacae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1357400"]),
        None,
        Some("."),
        Some("HMPREF2086_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobacterium antarcticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1358423.N180_00005";
/// let this_library_node_name2 = "1358423.N180_21135";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobacterium_antarcticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobacterium_antarcticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobacterium_antarcticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobacterium_antarcticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1358423"]),
        None,
        Some("."),
        Some("N180_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermofilum sp. 1910b nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1365176.N186_00005";
/// let this_library_node_name2 = "1365176.N186_09745";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermofilum_sp_1910b_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermofilum_sp_1910b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermofilum_sp_1910b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermofilum_sp_1910b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1365176"]),
        None,
        Some("."),
        Some("N186_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodobacteraceae bacterium HIMB11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1366046.HIMB11_00001";
/// let this_library_node_name2 = "1366046.HIMB11_03248";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodobacteraceae_bacterium_himb11_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodobacteraceae_bacterium_himb11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodobacteraceae_bacterium_himb11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodobacteraceae_bacterium_himb11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1366046"]),
        None,
        Some("."),
        Some("HIMB11_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ralstonia pickettii DTP0602 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1366050.N234_00005";
/// let this_library_node_name2 = "1366050.N234_37895";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ralstonia_pickettii_dtp0602_node_name(this_library_node_name1));
/// assert!(is_valid_string_ralstonia_pickettii_dtp0602_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ralstonia_pickettii_dtp0602_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ralstonia_pickettii_dtp0602_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1366050"]),
        None,
        Some("."),
        Some("N234_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter coli 76339 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1367491.BN865_00005c";
/// let this_library_node_name2 = "1367491.BN865_16410";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_coli_76339_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_coli_76339_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_coli_76339_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_coli_76339_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1367491"]),
        None,
        Some("."),
        Some("BN865_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus aminophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1367847.JCM7686_0066";
/// let this_library_node_name2 = "1367847.JCM7686_pAMI4p375";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_aminophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_aminophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_aminophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_aminophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1367847"]),
        None,
        Some("."),
        Some("JCM7686_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium sp. UMWGJ nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1370120.AUWR01000001_gene3246";
/// let this_library_node_name2 = "1370120.AUWR01000116_gene2611";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_sp_umwgj_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_sp_umwgj_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_sp_umwgj_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_sp_umwgj_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1370120"]),
        None,
        Some("."),
        Some("AUWR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium sp. UMWWY nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1370121.AUWS01000001_gene1065";
/// let this_library_node_name2 = "1370121.AUWS01000128_gene1147";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_sp_umwwy_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_sp_umwwy_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_sp_umwwy_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_sp_umwwy_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1370121"]),
        None,
        Some("."),
        Some("AUWS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium undicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1370122.JHXQ01000001_gene402";
/// let this_library_node_name2 = "1370122.JHXQ01000050_gene3505";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_undicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_undicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_undicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_undicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1370122"]),
        None,
        Some("."),
        Some("JHXQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium iranicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1370125.AUWT01000001_gene4135";
/// let this_library_node_name2 = "1370125.AUWT01000119_gene2046";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_iranicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_iranicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_iranicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_iranicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1370125"]),
        None,
        Some("."),
        Some("AUWT01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Firmicutes bacterium ASF500 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1378168.N510_00001";
/// let this_library_node_name2 = "1378168.N510_03632";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_firmicutes_bacterium_asf500_node_name(this_library_node_name1));
/// assert!(is_valid_string_firmicutes_bacterium_asf500_node_name(this_library_node_name2));
/// assert!(!is_valid_string_firmicutes_bacterium_asf500_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_firmicutes_bacterium_asf500_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1378168"]),
        None,
        Some("."),
        Some("N510_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gemmatimonas sp. AP64 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1379270.AUXF01000001_gene1860";
/// let this_library_node_name2 = "1379270.AUXF01000007_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gemmatimonas_sp_ap64_node_name(this_library_node_name1));
/// assert!(is_valid_string_gemmatimonas_sp_ap64_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gemmatimonas_sp_ap64_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gemmatimonas_sp_ap64_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1379270"]),
        None,
        Some("."),
        Some("AUXF0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfonauticus sp. A7A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1379281.AVAG01000001_gene245";
/// let this_library_node_name2 = "1379281.AVAG01000115_gene396";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfonauticus_sp_a7a_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfonauticus_sp_a7a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfonauticus_sp_a7a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfonauticus_sp_a7a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1379281"]),
        None,
        Some("."),
        Some("AVAG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING candidate division ZIXI nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1379698.RBG1_1C00001G0001";
/// let this_library_node_name2 = "1379698.RBG1_1C00001G1906";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_candidate_division_zixi_node_name(this_library_node_name1));
/// assert!(is_valid_string_candidate_division_zixi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_candidate_division_zixi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_candidate_division_zixi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1379698"]),
        None,
        Some("."),
        Some("RBG1_1C00001G"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. FUKUSWIS1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1379701.JPJC01000001_gene2517";
/// let this_library_node_name2 = "1379701.JPJC01000285_gene1459";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_fukuswis1_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_fukuswis1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_fukuswis1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_fukuswis1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1379701"]),
        None,
        Some("."),
        Some("JPJC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mucispirillum schaedleri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1379858.N508_00003";
/// let this_library_node_name2 = "1379858.N508_02190";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mucispirillum_schaedleri_node_name(this_library_node_name1));
/// assert!(is_valid_string_mucispirillum_schaedleri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mucispirillum_schaedleri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mucispirillum_schaedleri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1379858"]),
        None,
        Some("."),
        Some("N508_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. URHA0041 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380346.JNIH01000001_gene4028";
/// let this_library_node_name2 = "1380346.JNIH01000118_gene6245";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_urha0041_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_urha0041_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_urha0041_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_urha0041_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380346"]),
        None,
        Some("."),
        Some("JNIH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geodermatophilaceae bacterium URHB0048 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380347.JNII01000001_gene4452";
/// let this_library_node_name2 = "1380347.JNII01000013_gene2761";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geodermatophilaceae_bacterium_urhb0048_node_name(this_library_node_name1));
/// assert!(is_valid_string_geodermatophilaceae_bacterium_urhb0048_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geodermatophilaceae_bacterium_urhb0048_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geodermatophilaceae_bacterium_urhb0048_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380347"]),
        None,
        Some("."),
        Some("JNII010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mesorhizobium sp. URHC0008 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380350.JIAP01000001_gene1050";
/// let this_library_node_name2 = "1380350.JIAP01000035_gene921";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mesorhizobium_sp_urhc0008_node_name(this_library_node_name1));
/// assert!(is_valid_string_mesorhizobium_sp_urhc0008_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mesorhizobium_sp_urhc0008_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mesorhizobium_sp_urhc0008_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380350"]),
        None,
        Some("."),
        Some("JIAP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellulomonas sp. URHE0023 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380354.JIAN01000001_gene3645";
/// let this_library_node_name2 = "1380354.JIAN01000013_gene3644";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellulomonas_sp_urhe0023_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellulomonas_sp_urhe0023_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellulomonas_sp_urhe0023_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellulomonas_sp_urhe0023_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380354"]),
        None,
        Some("."),
        Some("JIAN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bradyrhizobium sp. URHD0069 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380355.JNIJ01000001_gene3863";
/// let this_library_node_name2 = "1380355.JNIJ01000129_gene808";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bradyrhizobium_sp_urhd0069_node_name(this_library_node_name1));
/// assert!(is_valid_string_bradyrhizobium_sp_urhd0069_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bradyrhizobium_sp_urhd0069_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bradyrhizobium_sp_urhd0069_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380355"]),
        None,
        Some("."),
        Some("JNIJ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Blastococcus sp. URHD0036 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380356.JNIK01000001_gene2065";
/// let this_library_node_name2 = "1380356.JNIK01000021_gene4682";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_blastococcus_sp_urhd0036_node_name(this_library_node_name1));
/// assert!(is_valid_string_blastococcus_sp_urhd0036_node_name(this_library_node_name2));
/// assert!(!is_valid_string_blastococcus_sp_urhd0036_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_blastococcus_sp_urhd0036_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380356"]),
        None,
        Some("."),
        Some("JNIK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas sp. 23GOM1509m nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380358.JADJ01000001_gene1000";
/// let this_library_node_name2 = "1380358.JADJ01000041_gene5";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_sp_23gom1509m_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_sp_23gom1509m_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_sp_23gom1509m_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_sp_23gom1509m_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380358"]),
        None,
        Some("."),
        Some("JADJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfitobacter sp. 20GPM1509m nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380367.JIBC01000001_gene81";
/// let this_library_node_name2 = "1380367.JIBC01000027_gene1826";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfitobacter_sp_20gpm1509m_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfitobacter_sp_20gpm1509m_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfitobacter_sp_20gpm1509m_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfitobacter_sp_20gpm1509m_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380367"]),
        None,
        Some("."),
        Some("JIBC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Intrasporangiaceae bacterium URHB0013 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380370.JIBA01000001_gene2163";
/// let this_library_node_name2 = "1380370.JIBA01000019_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_intrasporangiaceae_bacterium_urhb0013_node_name(this_library_node_name1));
/// assert!(is_valid_string_intrasporangiaceae_bacterium_urhb0013_node_name(this_library_node_name2));
/// assert!(!is_valid_string_intrasporangiaceae_bacterium_urhb0013_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_intrasporangiaceae_bacterium_urhb0013_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380370"]),
        None,
        Some("."),
        Some("JIBA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ahrensia sp. 13GOM1096m nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380380.JIAX01000001_gene2850";
/// let this_library_node_name2 = "1380380.JIAX01000015_gene2994";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ahrensia_sp_13gom1096m_node_name(this_library_node_name1));
/// assert!(is_valid_string_ahrensia_sp_13gom1096m_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ahrensia_sp_13gom1096m_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ahrensia_sp_13gom1096m_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380380"]),
        None,
        Some("."),
        Some("JIAX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tenacibaculum sp. 47AGOM205m nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380384.JADN01000001_gene326";
/// let this_library_node_name2 = "1380384.JADN01000012_gene145";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tenacibaculum_sp_47agom205m_node_name(this_library_node_name1));
/// assert!(is_valid_string_tenacibaculum_sp_47agom205m_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tenacibaculum_sp_47agom205m_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tenacibaculum_sp_47agom205m_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380384"]),
        None,
        Some("."),
        Some("JADN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium sp. URHB0044 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380386.JIAW01000001_gene4477";
/// let this_library_node_name2 = "1380386.JIAW01000043_gene4083";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_sp_urhb0044_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_sp_urhb0044_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_sp_urhb0044_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_sp_urhb0044_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380386"]),
        None,
        Some("."),
        Some("JIAW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alcanivorax sp. 43BGOM46m nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380387.JADM01000001_gene100";
/// let this_library_node_name2 = "1380387.JADM01000051_gene494";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alcanivorax_sp_43bgom46m_node_name(this_library_node_name1));
/// assert!(is_valid_string_alcanivorax_sp_43bgom46m_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alcanivorax_sp_43bgom46m_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alcanivorax_sp_43bgom46m_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380387"]),
        None,
        Some("."),
        Some("JADM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Solirubrobacterales bacterium URHD0059 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380390.JIAT01000001_gene4982";
/// let this_library_node_name2 = "1380390.JIAT01000017_gene5392";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_solirubrobacterales_bacterium_urhd0059_node_name(this_library_node_name1));
/// assert!(is_valid_string_solirubrobacterales_bacterium_urhd0059_node_name(this_library_node_name2));
/// assert!(!is_valid_string_solirubrobacterales_bacterium_urhd0059_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_solirubrobacterales_bacterium_urhd0059_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380390"]),
        None,
        Some("."),
        Some("JIAT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dongia sp. URHE0060 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380391.JIAS01000001_gene2573";
/// let this_library_node_name2 = "1380391.JIAS01000020_gene1705";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dongia_sp_urhe0060_node_name(this_library_node_name1));
/// assert!(is_valid_string_dongia_sp_urhe0060_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dongia_sp_urhe0060_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dongia_sp_urhe0060_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380391"]),
        None,
        Some("."),
        Some("JIAS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geodermatophilaceae bacterium URHA0031 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380393.JHVP01000001_gene2006";
/// let this_library_node_name2 = "1380393.JHVP01000030_gene4846";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geodermatophilaceae_bacterium_urha0031_node_name(this_library_node_name1));
/// assert!(is_valid_string_geodermatophilaceae_bacterium_urha0031_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geodermatophilaceae_bacterium_urha0031_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geodermatophilaceae_bacterium_urha0031_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380393"]),
        None,
        Some("."),
        Some("JHVP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodospirillales bacterium URHD0088 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380394.JADL01000001_gene1945";
/// let this_library_node_name2 = "1380394.JADL01000034_gene560";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodospirillales_bacterium_urhd0088_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodospirillales_bacterium_urhd0088_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodospirillales_bacterium_urhd0088_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodospirillales_bacterium_urhd0088_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380394"]),
        None,
        Some("."),
        Some("JADL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anoxybacillus flavithermus yunnanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380408.AVGH01000001_gene2306";
/// let this_library_node_name2 = "1380408.AVGH01000067_gene1304";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anoxybacillus_flavithermus_yunnanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_anoxybacillus_flavithermus_yunnanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anoxybacillus_flavithermus_yunnanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anoxybacillus_flavithermus_yunnanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380408"]),
        None,
        Some("."),
        Some("AVGH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flaviramulus ichthyoenteri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380600.AUYN01000001_gene2184";
/// let this_library_node_name2 = "1380600.AUYN01000016_gene256";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flaviramulus_ichthyoenteri_node_name(this_library_node_name1));
/// assert!(is_valid_string_flaviramulus_ichthyoenteri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flaviramulus_ichthyoenteri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flaviramulus_ichthyoenteri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380600"]),
        None,
        Some("."),
        Some("AUYN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus darwinianus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1380763.BG53_00005";
/// let this_library_node_name2 = "1380763.BG53_15980";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_darwinianus_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_darwinianus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_darwinianus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_darwinianus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1380763"]),
        None,
        Some("."),
        Some("BG53_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aliihoeflea sp. 2WW nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1381123.AYOD01000001_gene1000";
/// let this_library_node_name2 = "1381123.AYOD01000069_gene172";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aliihoeflea_sp_2ww_node_name(this_library_node_name1));
/// assert!(is_valid_string_aliihoeflea_sp_2ww_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aliihoeflea_sp_2ww_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aliihoeflea_sp_2ww_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1381123"]),
        None,
        Some("."),
        Some("AYOD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacterium sp. VCM10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1381751.JAJB01000001_gene2827";
/// let this_library_node_name2 = "1381751.JAJB01000141_gene2960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacterium_sp_vcm10_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacterium_sp_vcm10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacterium_sp_vcm10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacterium_sp_vcm10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1381751"]),
        None,
        Some("."),
        Some("JAJB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Asaia platycodi SF21 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1382230.ASAP_0001";
/// let this_library_node_name2 = "1382230.ASAP_3273";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_asaia_platycodi_sf21_node_name(this_library_node_name1));
/// assert!(is_valid_string_asaia_platycodi_sf21_node_name(this_library_node_name2));
/// assert!(!is_valid_string_asaia_platycodi_sf21_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_asaia_platycodi_sf21_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1382230"]),
        None,
        Some("."),
        Some("ASAP_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caulobacteraceae bacterium PMMR1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1382303.JPOM01000001_gene1";
/// let this_library_node_name2 = "1382303.JPOM01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caulobacteraceae_bacterium_pmmr1_node_name(this_library_node_name1));
/// assert!(is_valid_string_caulobacteraceae_bacterium_pmmr1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caulobacteraceae_bacterium_pmmr1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caulobacteraceae_bacterium_pmmr1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1382303"]),
        None,
        Some("."),
        Some("JPOM01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alicyclobacillus macrosporangiidus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1382304.JNIL01000001_gene1";
/// let this_library_node_name2 = "1382304.JNIL01000002_gene3620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alicyclobacillus_macrosporangiidus_node_name(this_library_node_name1));
/// assert!(is_valid_string_alicyclobacillus_macrosporangiidus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alicyclobacillus_macrosporangiidus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alicyclobacillus_macrosporangiidus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1382304"]),
        None,
        Some("."),
        Some("JNIL0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporosarcina sp. D27 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1382305.AZUC01000001_gene1565";
/// let this_library_node_name2 = "1382305.AZUC01000065_gene3186";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporosarcina_sp_d27_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporosarcina_sp_d27_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporosarcina_sp_d27_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporosarcina_sp_d27_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1382305"]),
        None,
        Some("."),
        Some("AZUC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermogemmatispora sp. PM5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1382306.JNIM01000001_gene1";
/// let this_library_node_name2 = "1382306.JNIM01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermogemmatispora_sp_pm5_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermogemmatispora_sp_pm5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermogemmatispora_sp_pm5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermogemmatispora_sp_pm5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1382306"]),
        None,
        Some("."),
        Some("JNIM01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacillus vulcani nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1382315.JPOI01000001_gene1";
/// let this_library_node_name2 = "1382315.JPOI01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacillus_vulcani_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacillus_vulcani_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacillus_vulcani_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacillus_vulcani_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1382315"]),
        None,
        Some("."),
        Some("JPOI01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermomicrobiales sp. KI4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1382356.JQMP01000001_gene1000";
/// let this_library_node_name2 = "1382356.JQMP01000004_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermomicrobiales_sp_ki4_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermomicrobiales_sp_ki4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermomicrobiales_sp_ki4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermomicrobiales_sp_ki4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1382356"]),
        None,
        Some("."),
        Some("JQMP0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anoxybacillus tepidamans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1382358.JHVN01000001_gene1000";
/// let this_library_node_name2 = "1382358.JHVN01000046_gene2450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anoxybacillus_tepidamans_node_name(this_library_node_name1));
/// assert!(is_valid_string_anoxybacillus_tepidamans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anoxybacillus_tepidamans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anoxybacillus_tepidamans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1382358"]),
        None,
        Some("."),
        Some("JHVN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidobacterium sp. PMMR2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1382359.JIAL01000001_gene1";
/// let this_library_node_name2 = "1382359.JIAL01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidobacterium_sp_pmmr2_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidobacterium_sp_pmmr2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidobacterium_sp_pmmr2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidobacterium_sp_pmmr2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1382359"]),
        None,
        Some("."),
        Some("JIAL01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysinibacillus manganicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1384049.CD29_00010";
/// let this_library_node_name2 = "1384049.CD29_20295";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysinibacillus_manganicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysinibacillus_manganicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysinibacillus_manganicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysinibacillus_manganicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1384049"]),
        None,
        Some("."),
        Some("CD29_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arenimonas malthae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1384054.N790_00005";
/// let this_library_node_name2 = "1384054.N790_15265";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arenimonas_malthae_node_name(this_library_node_name1));
/// assert!(is_valid_string_arenimonas_malthae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arenimonas_malthae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arenimonas_malthae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1384054"]),
        None,
        Some("."),
        Some("N790_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arenimonas metalli nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1384056.N787_00005";
/// let this_library_node_name2 = "1384056.N787_14230";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arenimonas_metalli_node_name(this_library_node_name1));
/// assert!(is_valid_string_arenimonas_metalli_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arenimonas_metalli_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arenimonas_metalli_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1384056"]),
        None,
        Some("."),
        Some("N787_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysinibacillus sinduriensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1384057.CD33_00120";
/// let this_library_node_name2 = "1384057.CD33_20175";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysinibacillus_sinduriensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysinibacillus_sinduriensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysinibacillus_sinduriensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysinibacillus_sinduriensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1384057"]),
        None,
        Some("."),
        Some("CD33_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus albus AD2013 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1384065.JAGS01000001_gene100";
/// let this_library_node_name2 = "1384065.JAGS01000006_gene64";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_albus_ad2013_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_albus_ad2013_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_albus_ad2013_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_albus_ad2013_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1384065"]),
        None,
        Some("."),
        Some("JAGS0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus flavefaciens AE3010 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1384066.JAGT01000001_gene1";
/// let this_library_node_name2 = "1384066.JAGT01000003_gene2950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_flavefaciens_ae3010_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_flavefaciens_ae3010_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_flavefaciens_ae3010_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_flavefaciens_ae3010_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1384066"]),
        None,
        Some("."),
        Some("JAGT0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Adlercreutzia equolifaciens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1384484.AEQU_0001";
/// let this_library_node_name2 = "1384484.AEQU_2281";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_adlercreutzia_equolifaciens_node_name(this_library_node_name1));
/// assert!(is_valid_string_adlercreutzia_equolifaciens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_adlercreutzia_equolifaciens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_adlercreutzia_equolifaciens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1384484"]),
        None,
        Some("."),
        Some("AEQU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Francisella sp. W121067 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385420.FRA_17c00050";
/// let this_library_node_name2 = "1385420.FRA_9c00040";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_francisella_sp_w121067_node_name(this_library_node_name1));
/// assert!(is_valid_string_francisella_sp_w121067_node_name(this_library_node_name2));
/// assert!(!is_valid_string_francisella_sp_w121067_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_francisella_sp_w121067_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385420"]),
        None,
        Some("."),
        Some("FRA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pontibacillus halophilus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385510.N781_00005";
/// let this_library_node_name2 = "1385510.N781_18445";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pontibacillus_halophilus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pontibacillus_halophilus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pontibacillus_halophilus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pontibacillus_halophilus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385510"]),
        None,
        Some("."),
        Some("N781_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pontibacillus marinus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385511.N783_00005";
/// let this_library_node_name2 = "1385511.N783_21995";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pontibacillus_marinus_node_name(this_library_node_name1));
/// assert!(is_valid_string_pontibacillus_marinus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pontibacillus_marinus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pontibacillus_marinus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385511"]),
        None,
        Some("."),
        Some("N783_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pontibacillus litoralis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385512.N784_00005";
/// let this_library_node_name2 = "1385512.N784_16590";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pontibacillus_litoralis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pontibacillus_litoralis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pontibacillus_litoralis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pontibacillus_litoralis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385512"]),
        None,
        Some("."),
        Some("N784_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pontibacillus chungwhensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385513.N780_00005";
/// let this_library_node_name2 = "1385513.N780_20115";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pontibacillus_chungwhensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pontibacillus_chungwhensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pontibacillus_chungwhensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pontibacillus_chungwhensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385513"]),
        None,
        Some("."),
        Some("N780_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pontibacillus yanchengensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385514.N782_00005";
/// let this_library_node_name2 = "1385514.N782_21940";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pontibacillus_yanchengensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pontibacillus_yanchengensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pontibacillus_yanchengensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pontibacillus_yanchengensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385514"]),
        None,
        Some("."),
        Some("N782_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysobacter defluvii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385515.N791_00005";
/// let this_library_node_name2 = "1385515.N791_14865";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysobacter_defluvii_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysobacter_defluvii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysobacter_defluvii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysobacter_defluvii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385515"]),
        None,
        Some("."),
        Some("N791_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysobacter daejeonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385517.N800_00015";
/// let this_library_node_name2 = "1385517.N800_15390";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysobacter_daejeonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysobacter_daejeonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysobacter_daejeonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysobacter_daejeonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385517"]),
        None,
        Some("."),
        Some("N800_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Knoellia flava nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385518.N798_00005";
/// let this_library_node_name2 = "1385518.N798_17520";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_knoellia_flava_node_name(this_library_node_name1));
/// assert!(is_valid_string_knoellia_flava_node_name(this_library_node_name2));
/// assert!(!is_valid_string_knoellia_flava_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_knoellia_flava_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385518"]),
        None,
        Some("."),
        Some("N798_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Knoellia aerolata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385519.N801_00005";
/// let this_library_node_name2 = "1385519.N801_20005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_knoellia_aerolata_node_name(this_library_node_name1));
/// assert!(is_valid_string_knoellia_aerolata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_knoellia_aerolata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_knoellia_aerolata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385519"]),
        None,
        Some("."),
        Some("N801_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Knoellia sinensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385520.N802_00005";
/// let this_library_node_name2 = "1385520.N802_19540";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_knoellia_sinensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_knoellia_sinensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_knoellia_sinensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_knoellia_sinensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385520"]),
        None,
        Some("."),
        Some("N802_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Knoellia subterranea nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385521.N803_00010";
/// let this_library_node_name2 = "1385521.N803_17595";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_knoellia_subterranea_node_name(this_library_node_name1));
/// assert!(is_valid_string_knoellia_subterranea_node_name(this_library_node_name2));
/// assert!(!is_valid_string_knoellia_subterranea_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_knoellia_subterranea_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385521"]),
        None,
        Some("."),
        Some("N803_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptolyngbya sp. Heron nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1385935.N836_00005";
/// let this_library_node_name2 = "1385935.N836_36660";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptolyngbya_sp_heron_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptolyngbya_sp_heron_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptolyngbya_sp_heron_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptolyngbya_sp_heron_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1385935"]),
        None,
        Some("."),
        Some("N836_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Intrasporangium oryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1386089.N865_00005";
/// let this_library_node_name2 = "1386089.N865_21930";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_intrasporangium_oryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_intrasporangium_oryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_intrasporangium_oryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_intrasporangium_oryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1386089"]),
        None,
        Some("."),
        Some("N865_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gordonia amicalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1386969.AWTB01000001_gene1797";
/// let this_library_node_name2 = "1386969.AWTB01000117_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gordonia_amicalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_gordonia_amicalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gordonia_amicalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gordonia_amicalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1386969"]),
        None,
        Some("."),
        Some("AWTB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Schmidhempelia bombi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1387197.AWGA01000002_gene1517";
/// let this_library_node_name2 = "1387197.AWGA01000079_gene146";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_schmidhempelia_bombi_node_name(this_library_node_name1));
/// assert!(is_valid_string_schmidhempelia_bombi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_schmidhempelia_bombi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_schmidhempelia_bombi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1387197"]),
        None,
        Some("."),
        Some("AWGA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylophilus sp. OH31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1387312.BAUS01000001_gene1081";
/// let this_library_node_name2 = "1387312.BAUS01000016_gene2599";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylophilus_sp_oh31_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylophilus_sp_oh31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylophilus_sp_oh31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylophilus_sp_oh31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1387312"]),
        None,
        Some("."),
        Some("BAUS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas mosselii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1388763.O165_000015";
/// let this_library_node_name2 = "1388763.O165_029050";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_mosselii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_mosselii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_mosselii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_mosselii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1388763"]),
        None,
        Some("."),
        Some("O165_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leifsonia xyli cynodontis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1389489.O159_00010";
/// let this_library_node_name2 = "1389489.O159_28850";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leifsonia_xyli_cynodontis_node_name(this_library_node_name1));
/// assert!(is_valid_string_leifsonia_xyli_cynodontis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leifsonia_xyli_cynodontis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leifsonia_xyli_cynodontis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1389489"]),
        None,
        Some("."),
        Some("O159_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas mendocina EGDAQ5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1390370.O203_00005";
/// let this_library_node_name2 = "1390370.O203_24305";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_mendocina_egdaq5_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_mendocina_egdaq5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_mendocina_egdaq5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_mendocina_egdaq5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1390370"]),
        None,
        Some("."),
        Some("O203_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium bifermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1391646.AVSU01000001_gene204";
/// let this_library_node_name2 = "1391646.AVSU01000180_gene1360";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_bifermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_bifermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_bifermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_bifermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1391646"]),
        None,
        Some("."),
        Some("AVSU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. AdeTY nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1391647.AVSV01000002_gene1246";
/// let this_library_node_name2 = "1391647.AVSV01000066_gene23";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_adety_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_adety_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_adety_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_adety_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1391647"]),
        None,
        Some("."),
        Some("AVSV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudozyma brasiliensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392244.V5E2T2";
/// let this_library_node_name2 = "1392244.V5GWG2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudozyma_brasiliensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudozyma_brasiliensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudozyma_brasiliensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudozyma_brasiliensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392244"]),
        None,
        Some("."),
        Some("V5"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. HUN102 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392486.JIAF01000001_gene1";
/// let this_library_node_name2 = "1392486.JIAF01000004_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_hun102_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_hun102_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_hun102_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_hun102_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392486"]),
        None,
        Some("."),
        Some("JIAF0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium sp. AB3007 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392487.JIAD01000001_gene1";
/// let this_library_node_name2 = "1392487.JIAD01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_sp_ab3007_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_sp_ab3007_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_sp_ab3007_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_sp_ab3007_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392487"]),
        None,
        Some("."),
        Some("JIAD01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leeuwenhoekiella sp. HelI48 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392488.JHZY01000001_gene1633";
/// let this_library_node_name2 = "1392488.JHZY01000005_gene3707";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leeuwenhoekiella_sp_heli48_node_name(this_library_node_name1));
/// assert!(is_valid_string_leeuwenhoekiella_sp_heli48_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leeuwenhoekiella_sp_heli48_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leeuwenhoekiella_sp_heli48_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392488"]),
        None,
        Some("."),
        Some("JHZY0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leeuwenhoekiella sp. MAR2009132 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392489.JPOL01000001_gene3420";
/// let this_library_node_name2 = "1392489.JPOL01000004_gene3419";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leeuwenhoekiella_sp_mar2009132_node_name(this_library_node_name1));
/// assert!(is_valid_string_leeuwenhoekiella_sp_mar2009132_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leeuwenhoekiella_sp_mar2009132_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leeuwenhoekiella_sp_mar2009132_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392489"]),
        None,
        Some("."),
        Some("JPOL0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sediminibacter sp. HelI10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392490.JHZX01000001_gene1";
/// let this_library_node_name2 = "1392490.JHZX01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sediminibacter_sp_heli10_node_name(this_library_node_name1));
/// assert!(is_valid_string_sediminibacter_sp_heli10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sediminibacter_sp_heli10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sediminibacter_sp_heli10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392490"]),
        None,
        Some("."),
        Some("JHZX01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcaceae bacterium AE2021 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392491.JIAE01000001_gene1";
/// let this_library_node_name2 = "1392491.JIAE01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcaceae_bacterium_ae2021_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcaceae_bacterium_ae2021_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcaceae_bacterium_ae2021_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcaceae_bacterium_ae2021_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392491"]),
        None,
        Some("."),
        Some("JIAE01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium AC2031 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392493.JIAB01000001_gene1";
/// let this_library_node_name2 = "1392493.JIAB01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_ac2031_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_ac2031_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_ac2031_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_ac2031_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392493"]),
        None,
        Some("."),
        Some("JIAB01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Maribacter forsetii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392498.JQLH01000001_gene1";
/// let this_library_node_name2 = "1392498.JQLH01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_maribacter_forsetii_node_name(this_library_node_name1));
/// assert!(is_valid_string_maribacter_forsetii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_maribacter_forsetii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_maribacter_forsetii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392498"]),
        None,
        Some("."),
        Some("JQLH01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas ruminantium AC2024 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392501.JIAC01000001_gene1";
/// let this_library_node_name2 = "1392501.JIAC01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_ruminantium_ac2024_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_ruminantium_ac2024_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_ruminantium_ac2024_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_ruminantium_ac2024_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392501"]),
        None,
        Some("."),
        Some("JIAC01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas ruminantium AB3002 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392502.JNIO01000001_gene22";
/// let this_library_node_name2 = "1392502.JNIO01000008_gene3103";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_ruminantium_ab3002_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_ruminantium_ab3002_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_ruminantium_ab3002_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_ruminantium_ab3002_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392502"]),
        None,
        Some("."),
        Some("JNIO0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter nectaris nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392540.P256_00001";
/// let this_library_node_name2 = "1392540.P256_02625";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_nectaris_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_nectaris_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_nectaris_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_nectaris_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392540"]),
        None,
        Some("."),
        Some("P256_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bordetella hinzii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1392838.AWNM01000001_gene1718";
/// let this_library_node_name2 = "1392838.AWNM01000098_gene2854";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bordetella_hinzii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bordetella_hinzii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bordetella_hinzii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bordetella_hinzii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1392838"]),
        None,
        Some("."),
        Some("AWNM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium sp. 7101 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1394175.AWUN01000001_gene1027";
/// let this_library_node_name2 = "1394175.AWUN01000016_gene655";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_sp_7101_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_sp_7101_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_sp_7101_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_sp_7101_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1394175"]),
        None,
        Some("."),
        Some("AWUN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium sp. A11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1394176.AWUO01000001_gene1000";
/// let this_library_node_name2 = "1394176.AWUO01000038_gene414";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_sp_a11_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_sp_a11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_sp_a11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_sp_a11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1394176"]),
        None,
        Some("."),
        Some("AWUO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinomadura madurae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1394178.AWOO02000001_gene1189";
/// let this_library_node_name2 = "1394178.AWOO02000149_gene918";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinomadura_madurae_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinomadura_madurae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinomadura_madurae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinomadura_madurae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1394178"]),
        None,
        Some("."),
        Some("AWOO02000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporolactobacillus laevolacticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1395513.P343_00005";
/// let this_library_node_name2 = "1395513.P343_18325";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporolactobacillus_laevolacticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporolactobacillus_laevolacticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporolactobacillus_laevolacticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporolactobacillus_laevolacticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1395513"]),
        None,
        Some("."),
        Some("P343_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas moraviensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1395516.PMO01_00015";
/// let this_library_node_name2 = "1395516.PMO01_28950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_moraviensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_moraviensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_moraviensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_moraviensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1395516"]),
        None,
        Some("."),
        Some("PMO01_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas taeanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1395571.TMS3_0100005";
/// let this_library_node_name2 = "1395571.TMS3_0125090";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_taeanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_taeanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_taeanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_taeanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1395571"]),
        None,
        Some("."),
        Some("TMS3_01"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. MAEPY2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1395587.P364_0100005";
/// let this_library_node_name2 = "1395587.P364_0133680";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_maepy2_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_maepy2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_maepy2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_maepy2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1395587"]),
        None,
        Some("."),
        Some("P364_01"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haloferula sp. BvORR071 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1396141.BATP01000001_gene5285";
/// let this_library_node_name2 = "1396141.BATP01000066_gene1894";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haloferula_sp_bvorr071_node_name(this_library_node_name1));
/// assert!(is_valid_string_haloferula_sp_bvorr071_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haloferula_sp_bvorr071_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haloferula_sp_bvorr071_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1396141"]),
        None,
        Some("."),
        Some("BATP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Verrucomicrobium sp. BvORR034 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1396418.BATQ01000001_gene1237";
/// let this_library_node_name2 = "1396418.BATQ01000200_gene4810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_verrucomicrobium_sp_bvorr034_node_name(this_library_node_name1));
/// assert!(is_valid_string_verrucomicrobium_sp_bvorr034_node_name(this_library_node_name2));
/// assert!(!is_valid_string_verrucomicrobium_sp_bvorr034_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_verrucomicrobium_sp_bvorr034_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1396418"]),
        None,
        Some("."),
        Some("BATQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter sp. ES1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1396858.Q666_00005";
/// let this_library_node_name2 = "1396858.Q666_17020";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_sp_es1_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_sp_es1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_sp_es1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_sp_es1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1396858"]),
        None,
        Some("."),
        Some("Q666_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leucobacter sp. PH1c nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1397278.AYMV01000001_gene420";
/// let this_library_node_name2 = "1397278.AYMV01000073_gene1526";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leucobacter_sp_ph1c_node_name(this_library_node_name1));
/// assert!(is_valid_string_leucobacter_sp_ph1c_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leucobacter_sp_ph1c_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leucobacter_sp_ph1c_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1397278"]),
        None,
        Some("."),
        Some("AYMV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia sp. H1n nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1397284.AYMN01000001_gene2220";
/// let this_library_node_name2 = "1397284.AYMN01000247_gene4893";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_sp_h1n_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_sp_h1n_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_sp_h1n_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_sp_h1n_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1397284"]),
        None,
        Some("."),
        Some("AYMN01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alcanivorax sp. P2S70 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1397527.Q670_00005";
/// let this_library_node_name2 = "1397527.Q670_16935";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alcanivorax_sp_p2s70_node_name(this_library_node_name1));
/// assert!(is_valid_string_alcanivorax_sp_p2s70_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alcanivorax_sp_p2s70_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alcanivorax_sp_p2s70_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1397527"]),
        None,
        Some("."),
        Some("Q670_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas sp. PBN3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1397528.Q671_00005";
/// let this_library_node_name2 = "1397528.Q671_17825";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_sp_pbn3_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_sp_pbn3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_sp_pbn3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_sp_pbn3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1397528"]),
        None,
        Some("."),
        Some("Q671_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING alpha proteobacterium RS24 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1397666.RS24_00001";
/// let this_library_node_name2 = "1397666.RS24_02109";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alpha_proteobacterium_rs24_node_name(this_library_node_name1));
/// assert!(is_valid_string_alpha_proteobacterium_rs24_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alpha_proteobacterium_rs24_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alpha_proteobacterium_rs24_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1397666"]),
        None,
        Some("."),
        Some("RS24_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Exiguobacterium undae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1397693.KK211187_gene1";
/// let this_library_node_name2 = "1397693.KK211187_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_exiguobacterium_undae_node_name(this_library_node_name1));
/// assert!(is_valid_string_exiguobacterium_undae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_exiguobacterium_undae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_exiguobacterium_undae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1397693"]),
        None,
        Some("."),
        Some("KK211187_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Exiguobacterium marinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1397696.KK211189_gene1";
/// let this_library_node_name2 = "1397696.KK211189_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_exiguobacterium_marinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_exiguobacterium_marinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_exiguobacterium_marinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_exiguobacterium_marinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1397696"]),
        None,
        Some("."),
        Some("KK211189_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Exiguobacterium oxidotolerans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1397699.JNIS01000001_gene100";
/// let this_library_node_name2 = "1397699.JNIS01000003_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_exiguobacterium_oxidotolerans_node_name(this_library_node_name1));
/// assert!(is_valid_string_exiguobacterium_oxidotolerans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_exiguobacterium_oxidotolerans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_exiguobacterium_oxidotolerans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1397699"]),
        None,
        Some("."),
        Some("JNIS0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia valaisiana Tom4006 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1398491.P613_00010";
/// let this_library_node_name2 = "1398491.P613_04860";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_valaisiana_tom4006_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_valaisiana_tom4006_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_valaisiana_tom4006_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_valaisiana_tom4006_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1398491"]),
        None,
        Some("."),
        Some("P613_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Exiguobacterium sp. MH3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1399115.U719_00025";
/// let this_library_node_name2 = "1399115.U719_16675";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_exiguobacterium_sp_mh3_node_name(this_library_node_name1));
/// assert!(is_valid_string_exiguobacterium_sp_mh3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_exiguobacterium_sp_mh3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_exiguobacterium_sp_mh3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1399115"]),
        None,
        Some("."),
        Some("U719_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Holospora obtusa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1399147.P618_200001";
/// let this_library_node_name2 = "1399147.P618_201155";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_holospora_obtusa_node_name(this_library_node_name1));
/// assert!(is_valid_string_holospora_obtusa_node_name(this_library_node_name2));
/// assert!(!is_valid_string_holospora_obtusa_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_holospora_obtusa_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1399147"]),
        None,
        Some("."),
        Some("P618_20"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Enterobacter cloacae JD6301 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1399774.JDWH01000001_gene2333";
/// let this_library_node_name2 = "1399774.JDWH01000053_gene2237";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_enterobacter_cloacae_jd6301_node_name(this_library_node_name1));
/// assert!(is_valid_string_enterobacter_cloacae_jd6301_node_name(this_library_node_name2));
/// assert!(!is_valid_string_enterobacter_cloacae_jd6301_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_enterobacter_cloacae_jd6301_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1399774"]),
        None,
        Some("."),
        Some("JDWH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus fabifermentans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1400520.LFAB_00005";
/// let this_library_node_name2 = "1400520.LFAB_17620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_fabifermentans_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_fabifermentans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_fabifermentans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_fabifermentans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1400520"]),
        None,
        Some("."),
        Some("LFAB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibacter ubique HTCC7214 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1400524.KL370779_gene1";
/// let this_library_node_name2 = "1400524.KL370779_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibacter_ubique_htcc7214_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibacter_ubique_htcc7214_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibacter_ubique_htcc7214_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibacter_ubique_htcc7214_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1400524"]),
        None,
        Some("."),
        Some("KL370779_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pelagibacter ubique HTCC7217 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1400525.JNIU01000001_gene1";
/// let this_library_node_name2 = "1400525.JNIU01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pelagibacter_ubique_htcc7217_node_name(this_library_node_name1));
/// assert!(is_valid_string_pelagibacter_ubique_htcc7217_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pelagibacter_ubique_htcc7217_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pelagibacter_ubique_htcc7217_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1400525"]),
        None,
        Some("."),
        Some("JNIU01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium tuscaniense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1401064.HMPREF2129_00015";
/// let this_library_node_name2 = "1401064.HMPREF2129_10695";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_tuscaniense_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_tuscaniense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_tuscaniense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_tuscaniense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1401064"]),
        None,
        Some("."),
        Some("HMPREF2129_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oligella urethralis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1401065.HMPREF2130_00005";
/// let this_library_node_name2 = "1401065.HMPREF2130_12155";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oligella_urethralis_node_name(this_library_node_name1));
/// assert!(is_valid_string_oligella_urethralis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oligella_urethralis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oligella_urethralis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1401065"]),
        None,
        Some("."),
        Some("HMPREF2130_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Veillonella montpellierensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1401067.HMPREF0872_00015";
/// let this_library_node_name2 = "1401067.HMPREF0872_09010";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_veillonella_montpellierensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_veillonella_montpellierensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_veillonella_montpellierensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_veillonella_montpellierensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1401067"]),
        None,
        Some("."),
        Some("HMPREF0872_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella buccalis DNF00985 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1401078.HMPREF2140_00005";
/// let this_library_node_name2 = "1401078.HMPREF2140_11805";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_buccalis_dnf00985_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_buccalis_dnf00985_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_buccalis_dnf00985_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_buccalis_dnf00985_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1401078"]),
        None,
        Some("."),
        Some("HMPREF2140_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Endolissoclinum faulkneri L5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1401328.P856_1";
/// let this_library_node_name2 = "1401328.P856_99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_endolissoclinum_faulkneri_l5_node_name(this_library_node_name1));
/// assert!(is_valid_string_endolissoclinum_faulkneri_l5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_endolissoclinum_faulkneri_l5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_endolissoclinum_faulkneri_l5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1401328"]),
        None,
        Some("."),
        Some("P856_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfitobacter sp. H3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1402135.SUH3_00005";
/// let this_library_node_name2 = "1402135.SUH3_24620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfitobacter_sp_h3_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfitobacter_sp_h3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfitobacter_sp_h3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfitobacter_sp_h3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1402135"]),
        None,
        Some("."),
        Some("SUH3_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus simplex nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1403313.AXBR01000001_gene3916";
/// let this_library_node_name2 = "1403313.AXBR01000034_gene2313";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_simplex_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_simplex_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_simplex_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_simplex_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1403313"]),
        None,
        Some("."),
        Some("AXBR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Verrucomicrobium sp. BvORR106 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1403819.BATR01000001_gene1";
/// let this_library_node_name2 = "1403819.BATR01000209_gene6608";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_verrucomicrobium_sp_bvorr106_node_name(this_library_node_name1));
/// assert!(is_valid_string_verrucomicrobium_sp_bvorr106_node_name(this_library_node_name2));
/// assert!(!is_valid_string_verrucomicrobium_sp_bvorr106_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_verrucomicrobium_sp_bvorr106_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1403819"]),
        None,
        Some("."),
        Some("BATR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus anginosus DORA7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1403946.Q615_SPAC00001G0001";
/// let this_library_node_name2 = "1403946.Q615_SPAC00138G0011";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_anginosus_dora7_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_anginosus_dora7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_anginosus_dora7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_anginosus_dora7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1403946"]),
        None,
        Some("."),
        Some("Q615_SPAC00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Varibaculum cambriense DORA20 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1403948.Q618_VCMC00001G0001";
/// let this_library_node_name2 = "1403948.Q618_VCMC00003G0469";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_varibaculum_cambriense_dora20_node_name(this_library_node_name1));
/// assert!(is_valid_string_varibaculum_cambriense_dora20_node_name(this_library_node_name2));
/// assert!(!is_valid_string_varibaculum_cambriense_dora20_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_varibaculum_cambriense_dora20_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1403948"]),
        None,
        Some("."),
        Some("Q618_VCMC0000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium glycinophilum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1404245.CGLY_00005";
/// let this_library_node_name2 = "1404245.CGLY_16760";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_glycinophilum_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_glycinophilum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_glycinophilum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_glycinophilum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1404245"]),
        None,
        Some("."),
        Some("CGLY_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydia suis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1405296.Q499_0001";
/// let this_library_node_name2 = "1405296.Q499_0959";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydia_suis_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydia_suis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydia_suis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydia_suis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1405296"]),
        None,
        Some("."),
        Some("Q499_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Staphylococcus simulans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1405498.SSIM_00005";
/// let this_library_node_name2 = "1405498.SSIM_13755";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_staphylococcus_simulans_node_name(this_library_node_name1));
/// assert!(is_valid_string_staphylococcus_simulans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_staphylococcus_simulans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_staphylococcus_simulans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1405498"]),
        None,
        Some("."),
        Some("SSIM_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium beibuense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1406840.Q763_00005";
/// let this_library_node_name2 = "1406840.Q763_17755";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_beibuense_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_beibuense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_beibuense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_beibuense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1406840"]),
        None,
        Some("."),
        Some("Q763_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Synechococcus sp. NKBG15041c nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1407650.BAUB01000001_gene1";
/// let this_library_node_name2 = "1407650.BAUB01000043_gene2927";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_synechococcus_sp_nkbg15041c_node_name(this_library_node_name1));
/// assert!(is_valid_string_synechococcus_sp_nkbg15041c_node_name(this_library_node_name2));
/// assert!(!is_valid_string_synechococcus_sp_nkbg15041c_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_synechococcus_sp_nkbg15041c_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1407650"]),
        None,
        Some("."),
        Some("BAUB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Betaproteobacteria bacterium MOLA814 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408164.MOLA814_00001";
/// let this_library_node_name2 = "1408164.MOLA814_02739";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_betaproteobacteria_bacterium_mola814_node_name(this_library_node_name1));
/// assert!(is_valid_string_betaproteobacteria_bacterium_mola814_node_name(this_library_node_name2));
/// assert!(!is_valid_string_betaproteobacteria_bacterium_mola814_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_betaproteobacteria_bacterium_mola814_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408164"]),
        None,
        Some("."),
        Some("MOLA814_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sinorhizobium americanum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408224.SAMCCGM7_c0001";
/// let this_library_node_name2 = "1408224.SAMCCGM7_c6673";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sinorhizobium_americanum_node_name(this_library_node_name1));
/// assert!(is_valid_string_sinorhizobium_americanum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sinorhizobium_americanum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sinorhizobium_americanum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408224"]),
        None,
        Some("."),
        Some("SAMCCGM7_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vagococcus lutrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408226.T233_00001";
/// let this_library_node_name2 = "1408226.T233_01788";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vagococcus_lutrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_vagococcus_lutrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vagococcus_lutrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vagococcus_lutrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408226"]),
        None,
        Some("."),
        Some("T233_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacillus panacihumi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408254.T458_00005";
/// let this_library_node_name2 = "1408254.T458_28155";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacillus_panacihumi_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacillus_panacihumi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacillus_panacihumi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacillus_panacihumi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408254"]),
        None,
        Some("."),
        Some("T458_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium nucleatum W1481 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408287.AXUR01000001_gene1262";
/// let this_library_node_name2 = "1408287.AXUR01000185_gene2121";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_nucleatum_w1481_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_nucleatum_w1481_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_nucleatum_w1481_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_nucleatum_w1481_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408287"]),
        None,
        Some("."),
        Some("AXUR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. MB2021 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408303.JNJJ01000001_gene3530";
/// let this_library_node_name2 = "1408303.JNJJ01000173_gene2464";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_mb2021_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_mb2021_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_mb2021_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_mb2021_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408303"]),
        None,
        Some("."),
        Some("JNJJ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. FCS014 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408304.JAHA01000001_gene1605";
/// let this_library_node_name2 = "1408304.JAHA01000022_gene74";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_fcs014_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_fcs014_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_fcs014_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_fcs014_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408304"]),
        None,
        Some("."),
        Some("JAHA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. MC2021 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408306.JHXX01000001_gene1419";
/// let this_library_node_name2 = "1408306.JHXX01000035_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_mc2021_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_mc2021_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_mc2021_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_mc2021_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408306"]),
        None,
        Some("."),
        Some("JHXX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. MA2016 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408310.JHUW01000001_gene1217";
/// let this_library_node_name2 = "1408310.JHUW01000013_gene311";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_ma2016_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_ma2016_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_ma2016_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_ma2016_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408310"]),
        None,
        Some("."),
        Some("JHUW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oribacterium sp. FC2011 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408311.JNJM01000001_gene220";
/// let this_library_node_name2 = "1408311.JNJM01000068_gene39";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oribacterium_sp_fc2011_node_name(this_library_node_name1));
/// assert!(is_valid_string_oribacterium_sp_fc2011_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oribacterium_sp_fc2011_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oribacterium_sp_fc2011_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408311"]),
        None,
        Some("."),
        Some("JNJM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudobutyrivibrio sp. LB2011 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408312.JNJS01000001_gene1238";
/// let this_library_node_name2 = "1408312.JNJS01000010_gene441";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudobutyrivibrio_sp_lb2011_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudobutyrivibrio_sp_lb2011_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudobutyrivibrio_sp_lb2011_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudobutyrivibrio_sp_lb2011_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408312"]),
        None,
        Some("."),
        Some("JNJS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium AC2028 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408321.JNJD01000001_gene45";
/// let this_library_node_name2 = "1408321.JNJD01000014_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_ac2028_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_ac2028_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_ac2028_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_ac2028_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408321"]),
        None,
        Some("."),
        Some("JNJD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium AC3007 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408322.JHYK01000001_gene1440";
/// let this_library_node_name2 = "1408322.JHYK01000055_gene2160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_ac3007_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_ac3007_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_ac3007_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_ac3007_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408322"]),
        None,
        Some("."),
        Some("JHYK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium MA2020 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408323.JQKK01000001_gene2428";
/// let this_library_node_name2 = "1408323.JQKK01000050_gene295";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_ma2020_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_ma2020_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_ma2020_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_ma2020_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408323"]),
        None,
        Some("."),
        Some("JQKK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium MC2017 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408324.JNJK01000001_gene467";
/// let this_library_node_name2 = "1408324.JNJK01000063_gene1864";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_mc2017_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_mc2017_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_mc2017_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_mc2017_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408324"]),
        None,
        Some("."),
        Some("JNJK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acholeplasma equifetale nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408415.JHXL01000001_gene381";
/// let this_library_node_name2 = "1408415.JHXL01000024_gene1175";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acholeplasma_equifetale_node_name(this_library_node_name1));
/// assert!(is_valid_string_acholeplasma_equifetale_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acholeplasma_equifetale_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acholeplasma_equifetale_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408415"]),
        None,
        Some("."),
        Some("JHXL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acholeplasma hippikon nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408416.JNJT01000001_gene1";
/// let this_library_node_name2 = "1408416.JNJT01000017_gene257";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acholeplasma_hippikon_node_name(this_library_node_name1));
/// assert!(is_valid_string_acholeplasma_hippikon_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acholeplasma_hippikon_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acholeplasma_hippikon_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408416"]),
        None,
        Some("."),
        Some("JNJT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acholeplasma modicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408417.JHYB01000002_gene318";
/// let this_library_node_name2 = "1408417.JHYB01000008_gene1139";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acholeplasma_modicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_acholeplasma_modicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acholeplasma_modicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acholeplasma_modicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408417"]),
        None,
        Some("."),
        Some("JHYB0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidiphilium angustum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408418.JNJH01000001_gene2906";
/// let this_library_node_name2 = "1408418.JNJH01000207_gene3711";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidiphilium_angustum_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidiphilium_angustum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidiphilium_angustum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidiphilium_angustum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408418"]),
        None,
        Some("."),
        Some("JNJH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acidocella facilis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408419.JHYG01000001_gene1547";
/// let this_library_node_name2 = "1408419.JHYG01000048_gene1998";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acidocella_facilis_node_name(this_library_node_name1));
/// assert!(is_valid_string_acidocella_facilis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acidocella_facilis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acidocella_facilis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408419"]),
        None,
        Some("."),
        Some("JHYG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alkaliphilus transvaalensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408422.JHYF01000001_gene2643";
/// let this_library_node_name2 = "1408422.JHYF01000047_gene3384";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alkaliphilus_transvaalensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_alkaliphilus_transvaalensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alkaliphilus_transvaalensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alkaliphilus_transvaalensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408422"]),
        None,
        Some("."),
        Some("JHYF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Anaerovibrio lipolyticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408423.JHYA01000001_gene1000";
/// let this_library_node_name2 = "1408423.JHYA01000032_gene2432";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_anaerovibrio_lipolyticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_anaerovibrio_lipolyticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_anaerovibrio_lipolyticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_anaerovibrio_lipolyticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408423"]),
        None,
        Some("."),
        Some("JHYA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus bogoriensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408424.JHYI01000001_gene1822";
/// let this_library_node_name2 = "1408424.JHYI01000060_gene530";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_bogoriensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_bogoriensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_bogoriensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_bogoriensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408424"]),
        None,
        Some("."),
        Some("JHYI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bartonella elizabethae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408427.JADB01000001_gene199";
/// let this_library_node_name2 = "1408427.JADB01000045_gene1509";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bartonella_elizabethae_node_name(this_library_node_name1));
/// assert!(is_valid_string_bartonella_elizabethae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bartonella_elizabethae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bartonella_elizabethae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408427"]),
        None,
        Some("."),
        Some("JADB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bilophila wadsworthia ATCC49260 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408428.JNJP01000001_gene3068";
/// let this_library_node_name2 = "1408428.JNJP01000201_gene1229";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bilophila_wadsworthia_atcc49260_node_name(this_library_node_name1));
/// assert!(is_valid_string_bilophila_wadsworthia_atcc49260_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bilophila_wadsworthia_atcc49260_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bilophila_wadsworthia_atcc49260_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408428"]),
        None,
        Some("."),
        Some("JNJP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Crocinitomix catalasitica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408433.JHXV01000001_gene1000";
/// let this_library_node_name2 = "1408433.JHXV01000076_gene3786";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_crocinitomix_catalasitica_node_name(this_library_node_name1));
/// assert!(is_valid_string_crocinitomix_catalasitica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_crocinitomix_catalasitica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_crocinitomix_catalasitica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408433"]),
        None,
        Some("."),
        Some("JHXV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium cellulosolvens LD2006 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408436.JHXY01000001_gene504";
/// let this_library_node_name2 = "1408436.JHXY01000085_gene668";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_cellulosolvens_ld2006_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_cellulosolvens_ld2006_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_cellulosolvens_ld2006_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_cellulosolvens_ld2006_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408436"]),
        None,
        Some("."),
        Some("JHXY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Eubacterium desmolans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408437.JNJN01000001_gene1638";
/// let this_library_node_name2 = "1408437.JNJN01000097_gene2400";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_eubacterium_desmolans_node_name(this_library_node_name1));
/// assert!(is_valid_string_eubacterium_desmolans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_eubacterium_desmolans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_eubacterium_desmolans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408437"]),
        None,
        Some("."),
        Some("JNJN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Facklamia sourekii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408438.JADD01000001_gene436";
/// let this_library_node_name2 = "1408438.JADD01000051_gene543";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_facklamia_sourekii_node_name(this_library_node_name1));
/// assert!(is_valid_string_facklamia_sourekii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_facklamia_sourekii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_facklamia_sourekii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408438"]),
        None,
        Some("."),
        Some("JADD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Fusobacterium perfoetens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408439.JHXW01000001_gene1805";
/// let this_library_node_name2 = "1408439.JHXW01000027_gene1804";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_fusobacterium_perfoetens_node_name(this_library_node_name1));
/// assert!(is_valid_string_fusobacterium_perfoetens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_fusobacterium_perfoetens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_fusobacterium_perfoetens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408439"]),
        None,
        Some("."),
        Some("JHXW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter pametensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408442.JADE01000001_gene1361";
/// let this_library_node_name2 = "1408442.JADE01000013_gene1064";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_pametensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_pametensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_pametensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_pametensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408442"]),
        None,
        Some("."),
        Some("JADE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella fairfieldensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408444.JHYC01000001_gene1076";
/// let this_library_node_name2 = "1408444.JHYC01000063_gene2390";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_fairfieldensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_fairfieldensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_fairfieldensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_fairfieldensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408444"]),
        None,
        Some("."),
        Some("JHYC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Legionella sainthelensi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408445.JHXP01000001_gene1499";
/// let this_library_node_name2 = "1408445.JHXP01000065_gene2697";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_legionella_sainthelensi_node_name(this_library_node_name1));
/// assert!(is_valid_string_legionella_sainthelensi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_legionella_sainthelensi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_legionella_sainthelensi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408445"]),
        None,
        Some("."),
        Some("JHXP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium genavense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408452.JAGZ01000001_gene3078";
/// let this_library_node_name2 = "1408452.JAGZ01000025_gene3070";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_genavense_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_genavense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_genavense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_genavense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408452"]),
        None,
        Some("."),
        Some("JAGZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prolixibacter bellariivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408473.JHXO01000001_gene1943";
/// let this_library_node_name2 = "1408473.JHXO01000023_gene2531";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prolixibacter_bellariivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_prolixibacter_bellariivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prolixibacter_bellariivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prolixibacter_bellariivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408473"]),
        None,
        Some("."),
        Some("JHXO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobacterium sp. H1ai nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408813.AYMG01000001_gene3308";
/// let this_library_node_name2 = "1408813.AYMG01000065_gene1061";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobacterium_sp_h1ai_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobacterium_sp_h1ai_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobacterium_sp_h1ai_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobacterium_sp_h1ai_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408813"]),
        None,
        Some("."),
        Some("AYMG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium mangenotii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1408823.AXUS01000001_gene602";
/// let this_library_node_name2 = "1408823.AXUS01000082_gene114";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_mangenotii_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_mangenotii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_mangenotii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_mangenotii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1408823"]),
        None,
        Some("."),
        Some("AXUS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacteroides sp. Ga6A2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410608.JNKX01000001_gene1521";
/// let this_library_node_name2 = "1410608.JNKX01000089_gene2653";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacteroides_sp_ga6a2_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacteroides_sp_ga6a2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacteroides_sp_ga6a2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacteroides_sp_ga6a2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410608"]),
        None,
        Some("."),
        Some("JNKX010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema sp. C6A8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410609.JHVB01000001_gene1649";
/// let this_library_node_name2 = "1410609.JHVB01000024_gene947";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_sp_c6a8_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_sp_c6a8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_sp_c6a8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_sp_c6a8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410609"]),
        None,
        Some("."),
        Some("JHVB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oribacterium sp. P6A1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410612.JNKO01000001_gene2502";
/// let this_library_node_name2 = "1410612.JNKO01000095_gene2942";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oribacterium_sp_p6a1_node_name(this_library_node_name1));
/// assert!(is_valid_string_oribacterium_sp_p6a1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oribacterium_sp_p6a1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oribacterium_sp_p6a1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410612"]),
        None,
        Some("."),
        Some("JNKO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella sp. P6B1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410613.JNKF01000001_gene2365";
/// let this_library_node_name2 = "1410613.JNKF01000018_gene2771";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_sp_p6b1_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_sp_p6b1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_sp_p6b1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_sp_p6b1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410613"]),
        None,
        Some("."),
        Some("JNKF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudobutyrivibrio sp. MD2005 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410616.JHXE01000001_gene2346";
/// let this_library_node_name2 = "1410616.JHXE01000033_gene1524";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudobutyrivibrio_sp_md2005_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudobutyrivibrio_sp_md2005_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudobutyrivibrio_sp_md2005_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudobutyrivibrio_sp_md2005_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410616"]),
        None,
        Some("."),
        Some("JHXE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus sp. FC2018 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410617.JHXH01000001_gene708";
/// let this_library_node_name2 = "1410617.JHXH01000033_gene1599";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_sp_fc2018_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_sp_fc2018_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_sp_fc2018_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_sp_fc2018_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410617"]),
        None,
        Some("."),
        Some("JHXH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas sp. ND2010 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410618.JNKI01000001_gene1208";
/// let this_library_node_name2 = "1410618.JNKI01000066_gene1725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_sp_nd2010_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_sp_nd2010_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_sp_nd2010_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_sp_nd2010_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410618"]),
        None,
        Some("."),
        Some("JNKI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia sp. DD3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410619.SRDD_00010";
/// let this_library_node_name2 = "1410619.SRDD_46680";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_sp_dd3_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_sp_dd3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_sp_dd3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_sp_dd3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410619"]),
        None,
        Some("."),
        Some("SRDD_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shinella sp. DD12 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410620.SHLA_100c000010";
/// let this_library_node_name2 = "1410620.SHLA_9c001310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shinella_sp_dd12_node_name(this_library_node_name1));
/// assert!(is_valid_string_shinella_sp_dd12_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shinella_sp_dd12_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shinella_sp_dd12_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410620"]),
        None,
        Some("."),
        Some("SHLA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium C6A11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410622.JNKY01000001_gene1321";
/// let this_library_node_name2 = "1410622.JNKY01000019_gene1817";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_c6a11_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_c6a11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_c6a11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_c6a11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410622"]),
        None,
        Some("."),
        Some("JNKY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium FE2018 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410624.JNKK01000001_gene582";
/// let this_library_node_name2 = "1410624.JNKK01000119_gene1404";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_fe2018_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_fe2018_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_fe2018_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_fe2018_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410624"]),
        None,
        Some("."),
        Some("JNKK01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium MD2004 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410625.JHWK01000001_gene2082";
/// let this_library_node_name2 = "1410625.JHWK01000012_gene2081";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_md2004_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_md2004_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_md2004_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_md2004_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410625"]),
        None,
        Some("."),
        Some("JHWK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium NC2004 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410626.JHXB01000001_gene2036";
/// let this_library_node_name2 = "1410626.JHXB01000057_gene1173";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_nc2004_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_nc2004_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_nc2004_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_nc2004_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410626"]),
        None,
        Some("."),
        Some("JHXB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium ND2006 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410628.JNKS01000001_gene2224";
/// let this_library_node_name2 = "1410628.JNKS01000103_gene1329";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_nd2006_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_nd2006_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_nd2006_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_nd2006_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410628"]),
        None,
        Some("."),
        Some("JNKS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium P6A3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410630.JNKP01000001_gene1668";
/// let this_library_node_name2 = "1410630.JNKP01000010_gene1666";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_p6a3_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_p6a3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_p6a3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_p6a3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410630"]),
        None,
        Some("."),
        Some("JNKP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium P6B14 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410631.JHWZ01000001_gene1000";
/// let this_library_node_name2 = "1410631.JHWZ01000036_gene2201";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_p6b14_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_p6b14_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_p6b14_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_p6b14_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410631"]),
        None,
        Some("."),
        Some("JHWZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium V9D3004 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410632.JHWW01000001_gene1000";
/// let this_library_node_name2 = "1410632.JHWW01000034_gene2455";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_v9d3004_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_v9d3004_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_v9d3004_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_v9d3004_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410632"]),
        None,
        Some("."),
        Some("JHWW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium YSB2008 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410633.JHWR01000001_gene1201";
/// let this_library_node_name2 = "1410633.JHWR01000028_gene773";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_ysb2008_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_ysb2008_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_ysb2008_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_ysb2008_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410633"]),
        None,
        Some("."),
        Some("JHWR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Propionibacteriaceae bacterium P6A17 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410634.JHVD01000001_gene1394";
/// let this_library_node_name2 = "1410634.JHVD01000051_gene2511";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_propionibacteriaceae_bacterium_p6a17_node_name(this_library_node_name1));
/// assert!(is_valid_string_propionibacteriaceae_bacterium_p6a17_node_name(this_library_node_name2));
/// assert!(!is_valid_string_propionibacteriaceae_bacterium_p6a17_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_propionibacteriaceae_bacterium_p6a17_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410634"]),
        None,
        Some("."),
        Some("JHVD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcaceae bacterium AB4001 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410638.JHXJ01000001_gene1564";
/// let this_library_node_name2 = "1410638.JHXJ01000054_gene948";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcaceae_bacterium_ab4001_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcaceae_bacterium_ab4001_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcaceae_bacterium_ab4001_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcaceae_bacterium_ab4001_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410638"]),
        None,
        Some("."),
        Some("JHXJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio proteoclasticus P6B7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410650.JHWL01000001_gene1000";
/// let this_library_node_name2 = "1410650.JHWL01000058_gene3115";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_proteoclasticus_p6b7_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_proteoclasticus_p6b7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_proteoclasticus_p6b7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_proteoclasticus_p6b7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410650"]),
        None,
        Some("."),
        Some("JHWL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium lundense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410653.JHVC01000001_gene1353";
/// let this_library_node_name2 = "1410653.JHVC01000054_gene394";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_lundense_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_lundense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_lundense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_lundense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410653"]),
        None,
        Some("."),
        Some("JHVC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kandleria vitulina nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410658.JHWI01000001_gene1284";
/// let this_library_node_name2 = "1410658.JHWI01000055_gene1376";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kandleria_vitulina_node_name(this_library_node_name1));
/// assert!(is_valid_string_kandleria_vitulina_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kandleria_vitulina_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kandleria_vitulina_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410658"]),
        None,
        Some("."),
        Some("JHWI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospira multipara LB2003 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410661.JNKW01000001_gene430";
/// let this_library_node_name2 = "1410661.JNKW01000022_gene429";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospira_multipara_lb2003_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospira_multipara_lb2003_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospira_multipara_lb2003_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospira_multipara_lb2003_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410661"]),
        None,
        Some("."),
        Some("JNKW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mitsuokella jalaludinii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410665.JNKR01000001_gene221";
/// let this_library_node_name2 = "1410665.JNKR01000062_gene984";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mitsuokella_jalaludinii_node_name(this_library_node_name1));
/// assert!(is_valid_string_mitsuokella_jalaludinii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mitsuokella_jalaludinii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mitsuokella_jalaludinii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410665"]),
        None,
        Some("."),
        Some("JNKR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prevotella brevis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410666.JHXG01000001_gene715";
/// let this_library_node_name2 = "1410666.JHXG01000024_gene271";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prevotella_brevis_node_name(this_library_node_name1));
/// assert!(is_valid_string_prevotella_brevis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prevotella_brevis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prevotella_brevis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410666"]),
        None,
        Some("."),
        Some("JHXG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Proteiniclasticum ruminis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410668.JNKC01000001_gene1163";
/// let this_library_node_name2 = "1410668.JNKC01000024_gene545";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_proteiniclasticum_ruminis_node_name(this_library_node_name1));
/// assert!(is_valid_string_proteiniclasticum_ruminis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_proteiniclasticum_ruminis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_proteiniclasticum_ruminis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410668"]),
        None,
        Some("."),
        Some("JNKC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus flavefaciens MA2007 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410670.JHXF01000001_gene2456";
/// let this_library_node_name2 = "1410670.JHXF01000033_gene2347";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_flavefaciens_ma2007_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_flavefaciens_ma2007_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_flavefaciens_ma2007_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_flavefaciens_ma2007_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410670"]),
        None,
        Some("."),
        Some("JHXF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sharpea azabuensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410674.JNKU01000001_gene178";
/// let this_library_node_name2 = "1410674.JNKU01000094_gene960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sharpea_azabuensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sharpea_azabuensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sharpea_azabuensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sharpea_azabuensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410674"]),
        None,
        Some("."),
        Some("JNKU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Succinivibrio dextrinosolvens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1410676.JNKL01000001_gene890";
/// let this_library_node_name2 = "1410676.JNKL01000108_gene1988";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_succinivibrio_dextrinosolvens_node_name(this_library_node_name1));
/// assert!(is_valid_string_succinivibrio_dextrinosolvens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_succinivibrio_dextrinosolvens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_succinivibrio_dextrinosolvens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1410676"]),
        None,
        Some("."),
        Some("JNKL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobiales bacterium YIM77505 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1411123.JQNH01000001_gene1";
/// let this_library_node_name2 = "1411123.JQNH01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobiales_bacterium_yim77505_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobiales_bacterium_yim77505_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobiales_bacterium_yim77505_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobiales_bacterium_yim77505_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1411123"]),
        None,
        Some("."),
        Some("JQNH01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium MOLA455 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1411685.U062_00002";
/// let this_library_node_name2 = "1411685.U062_02379";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_mola455_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_mola455_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_mola455_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_mola455_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1411685"]),
        None,
        Some("."),
        Some("U062_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium sp. JCB nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1414719.CBYN010000001_gene895";
/// let this_library_node_name2 = "1414719.CBYN010000243_gene1080";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_sp_jcb_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_sp_jcb_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_sp_jcb_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_sp_jcb_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1414719"]),
        None,
        Some("."),
        Some("CBYN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. JCC nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1414720.CBYM010000001_gene675";
/// let this_library_node_name2 = "1414720.CBYM010000100_gene2028";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_jcc_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_jcc_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_jcc_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_jcc_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1414720"]),
        None,
        Some("."),
        Some("CBYM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nocardia nova nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1415166.NONO_c00010";
/// let this_library_node_name2 = "1415166.NONO_c76460";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nocardia_nova_node_name(this_library_node_name1));
/// assert!(is_valid_string_nocardia_nova_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nocardia_nova_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nocardia_nova_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1415166"]),
        None,
        Some("."),
        Some("NONO_c"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. TKP nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1415630.U771_00005";
/// let this_library_node_name2 = "1415630.U771_31997";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_tkp_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_tkp_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_tkp_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_tkp_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1415630"]),
        None,
        Some("."),
        Some("U771_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter sp. MCTG268 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1415754.JQMK01000001_gene3901";
/// let this_library_node_name2 = "1415754.JQMK01000014_gene660";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_sp_mctg268_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_sp_mctg268_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_sp_mctg268_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_sp_mctg268_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1415754"]),
        None,
        Some("."),
        Some("JQMK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas sp. TG39a nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1415755.JQLV01000001_gene1000";
/// let this_library_node_name2 = "1415755.JQLV01000002_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_sp_tg39a_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_sp_tg39a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_sp_tg39a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_sp_tg39a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1415755"]),
        None,
        Some("."),
        Some("JQLV0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanicola sp. MCTG156 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1415756.JQMY01000001_gene1000";
/// let this_library_node_name2 = "1415756.JQMY01000005_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanicola_sp_mctg156_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanicola_sp_mctg156_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanicola_sp_mctg156_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanicola_sp_mctg156_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1415756"]),
        None,
        Some("."),
        Some("JQMY0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium botulinum 202F nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1415774.U728_1";
/// let this_library_node_name2 = "1415774.U728_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_botulinum_202f_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_botulinum_202f_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_botulinum_202f_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_botulinum_202f_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1415774"]),
        None,
        Some("."),
        Some("U728_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium baratii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1415775.U729_1";
/// let this_library_node_name2 = "1415775.U729_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_baratii_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_baratii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_baratii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_baratii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1415775"]),
        None,
        Some("."),
        Some("U729_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porticoccus hydrocarbonoclasticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1415778.JQMM01000001_gene1";
/// let this_library_node_name2 = "1415778.JQMM01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porticoccus_hydrocarbonoclasticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_porticoccus_hydrocarbonoclasticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porticoccus_hydrocarbonoclasticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porticoccus_hydrocarbonoclasticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1415778"]),
        None,
        Some("."),
        Some("JQMM01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polycyclovorans algicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1415779.JOMH01000001_gene1";
/// let this_library_node_name2 = "1415779.JOMH01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polycyclovorans_algicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_polycyclovorans_algicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polycyclovorans_algicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polycyclovorans_algicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1415779"]),
        None,
        Some("."),
        Some("JOMH01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Algiphilus aromaticivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1415780.JPOG01000001_gene1";
/// let this_library_node_name2 = "1415780.JPOG01000002_gene3421";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_algiphilus_aromaticivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_algiphilus_aromaticivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_algiphilus_aromaticivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_algiphilus_aromaticivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1415780"]),
        None,
        Some("."),
        Some("JPOG0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium paraoxydans DH1b nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1416752.AYME01000001_gene417";
/// let this_library_node_name2 = "1416752.AYME01000045_gene184";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_paraoxydans_dh1b_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_paraoxydans_dh1b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_paraoxydans_dh1b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_paraoxydans_dh1b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1416752"]),
        None,
        Some("."),
        Some("AYME010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leifsonia aquatica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1416759.AYMR01000001_gene1440";
/// let this_library_node_name2 = "1416759.AYMR01000076_gene1844";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leifsonia_aquatica_node_name(this_library_node_name1));
/// assert!(is_valid_string_leifsonia_aquatica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leifsonia_aquatica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leifsonia_aquatica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1416759"]),
        None,
        Some("."),
        Some("AYMR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myroides odoratimimus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1416760.AYMS01000001_gene1912";
/// let this_library_node_name2 = "1416760.AYMS01000183_gene1999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myroides_odoratimimus_node_name(this_library_node_name1));
/// assert!(is_valid_string_myroides_odoratimimus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myroides_odoratimimus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myroides_odoratimimus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1416760"]),
        None,
        Some("."),
        Some("AYMS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Borrelia persica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1417230.AYOT01000001_gene1527";
/// let this_library_node_name2 = "1417230.AYOT01000245_gene611";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_borrelia_persica_node_name(this_library_node_name1));
/// assert!(is_valid_string_borrelia_persica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_borrelia_persica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_borrelia_persica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1417230"]),
        None,
        Some("."),
        Some("AYOT01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Defluviimonas sp. 20V17 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1417296.U879_00005";
/// let this_library_node_name2 = "1417296.U879_21500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_defluviimonas_sp_20v17_node_name(this_library_node_name1));
/// assert!(is_valid_string_defluviimonas_sp_20v17_node_name(this_library_node_name2));
/// assert!(!is_valid_string_defluviimonas_sp_20v17_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_defluviimonas_sp_20v17_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1417296"]),
        None,
        Some("."),
        Some("U879_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas mandelii PD30 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1419583.V466_00010";
/// let this_library_node_name2 = "1419583.V466_31335";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_mandelii_pd30_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_mandelii_pd30_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_mandelii_pd30_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_mandelii_pd30_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1419583"]),
        None,
        Some("."),
        Some("V466_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptococcus sp. VT 162 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1419814.V470_00005";
/// let this_library_node_name2 = "1419814.V470_10440";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptococcus_sp_vt_162_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptococcus_sp_vt_162_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptococcus_sp_vt_162_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptococcus_sp_vt_162_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1419814"]),
        None,
        Some("."),
        Some("V470_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phaeobacter gallaeciensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423144.Gal_00001";
/// let this_library_node_name2 = "1423144.Gal_04465";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phaeobacter_gallaeciensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_phaeobacter_gallaeciensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phaeobacter_gallaeciensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phaeobacter_gallaeciensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423144"]),
        None,
        Some("."),
        Some("Gal_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. SJS nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423321.AS29_00015";
/// let this_library_node_name2 = "1423321.AS29_22330";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_sjs_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_sjs_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_sjs_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_sjs_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423321"]),
        None,
        Some("."),
        Some("AS29_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus apodemi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423724.BAMM01000001_gene1";
/// let this_library_node_name2 = "1423724.BAMM01000063_gene2200";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_apodemi_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_apodemi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_apodemi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_apodemi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423724"]),
        None,
        Some("."),
        Some("BAMM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus casei DSM20011 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423732.BALS01000001_gene1262";
/// let this_library_node_name2 = "1423732.BALS01000178_gene533";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_casei_dsm20011_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_casei_dsm20011_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_casei_dsm20011_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_casei_dsm20011_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423732"]),
        None,
        Some("."),
        Some("BALS01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus composti nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423734.JCM14202_1";
/// let this_library_node_name2 = "1423734.JCM14202_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_composti_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_composti_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_composti_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_composti_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423734"]),
        None,
        Some("."),
        Some("JCM14202_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus farraginis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423743.JCM14108_1";
/// let this_library_node_name2 = "1423743.JCM14108_99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_farraginis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_farraginis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_farraginis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_farraginis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423743"]),
        None,
        Some("."),
        Some("JCM14108_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus fuchuensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423747.BAMJ01000001_gene1";
/// let this_library_node_name2 = "1423747.BAMJ01000070_gene2183";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_fuchuensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_fuchuensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_fuchuensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_fuchuensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423747"]),
        None,
        Some("."),
        Some("BAMJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus gallinarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423748.BALB01000001_gene1";
/// let this_library_node_name2 = "1423748.BALB01000074_gene2106";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_gallinarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_gallinarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_gallinarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_gallinarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423748"]),
        None,
        Some("."),
        Some("BALB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus hamsteri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423754.BALY01000001_gene1573";
/// let this_library_node_name2 = "1423754.BALY01000081_gene701";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_hamsteri_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_hamsteri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_hamsteri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_hamsteri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423754"]),
        None,
        Some("."),
        Some("BALY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus hayakitensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423755.BAML01000001_gene1";
/// let this_library_node_name2 = "1423755.BAML01000082_gene1705";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_hayakitensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_hayakitensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_hayakitensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_hayakitensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423755"]),
        None,
        Some("."),
        Some("BAML010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus hominis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423758.BN55_00005";
/// let this_library_node_name2 = "1423758.BN55_09975";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_hominis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_hominis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_hominis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_hominis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423758"]),
        None,
        Some("."),
        Some("BN55_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus kitasatonis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423767.BALU01000001_gene1383";
/// let this_library_node_name2 = "1423767.BALU01000035_gene1871";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_kitasatonis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_kitasatonis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_kitasatonis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_kitasatonis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423767"]),
        None,
        Some("."),
        Some("BALU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus nodensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423775.BAMN01000001_gene2508";
/// let this_library_node_name2 = "1423775.BAMN01000050_gene92";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_nodensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_nodensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_nodensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_nodensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423775"]),
        None,
        Some("."),
        Some("BAMN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus otakiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423780.LOT_0001";
/// let this_library_node_name2 = "1423780.LOT_2310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_otakiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_otakiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_otakiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_otakiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423780"]),
        None,
        Some("."),
        Some("LOT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus pasteurii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423790.BN53_00005";
/// let this_library_node_name2 = "1423790.BN53_09900";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_pasteurii_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_pasteurii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_pasteurii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_pasteurii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423790"]),
        None,
        Some("."),
        Some("BN53_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus sucicola nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423806.JCM15457_1";
/// let this_library_node_name2 = "1423806.JCM15457_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_sucicola_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_sucicola_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_sucicola_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_sucicola_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423806"]),
        None,
        Some("."),
        Some("JCM15457_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus suebicus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423807.BACO01000001_gene1";
/// let this_library_node_name2 = "1423807.BACO01000143_gene2572";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_suebicus_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_suebicus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_suebicus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_suebicus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423807"]),
        None,
        Some("."),
        Some("BACO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus vaginalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423814.HMPREF0549_0001";
/// let this_library_node_name2 = "1423814.HMPREF0549_1870";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_vaginalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_vaginalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_vaginalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_vaginalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423814"]),
        None,
        Some("."),
        Some("HMPREF0549_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus versmoldensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423815.BACR01000001_gene1";
/// let this_library_node_name2 = "1423815.BACR01000100_gene2399";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_versmoldensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_versmoldensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_versmoldensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_versmoldensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423815"]),
        None,
        Some("."),
        Some("BACR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus zeae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1423816.BACQ01000001_gene1";
/// let this_library_node_name2 = "1423816.BACQ01000105_gene2824";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_zeae_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_zeae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_zeae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_zeae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1423816"]),
        None,
        Some("."),
        Some("BACQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Advenella kashmirensis W13003 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1424334.W822_00005";
/// let this_library_node_name2 = "1424334.W822_22995";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_advenella_kashmirensis_w13003_node_name(this_library_node_name1));
/// assert!(is_valid_string_advenella_kashmirensis_w13003_node_name(this_library_node_name2));
/// assert!(!is_valid_string_advenella_kashmirensis_w13003_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_advenella_kashmirensis_w13003_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1424334"]),
        None,
        Some("."),
        Some("W822_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hepatoplasma crinochetorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1427984.X271_00001";
/// let this_library_node_name2 = "1427984.X271_00620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hepatoplasma_crinochetorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_hepatoplasma_crinochetorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hepatoplasma_crinochetorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hepatoplasma_crinochetorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1427984"]),
        None,
        Some("."),
        Some("X271_00"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus rhodochrous nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1429046.RR21198_0001";
/// let this_library_node_name2 = "1429046.RR21198_6039";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_rhodochrous_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_rhodochrous_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_rhodochrous_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_rhodochrous_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1429046"]),
        None,
        Some("."),
        Some("RR21198_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Stenotrophomonas maltophilia 5BAI2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1429851.X548_00020";
/// let this_library_node_name2 = "1429851.X548_20825";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_stenotrophomonas_maltophilia_5bai2_node_name(this_library_node_name1));
/// assert!(is_valid_string_stenotrophomonas_maltophilia_5bai2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_stenotrophomonas_maltophilia_5bai2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_stenotrophomonas_maltophilia_5bai2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1429851"]),
        None,
        Some("."),
        Some("X548_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Afipia sp. P5210 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1429916.X566_00010";
/// let this_library_node_name2 = "1429916.X566_24635";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_afipia_sp_p5210_node_name(this_library_node_name1));
/// assert!(is_valid_string_afipia_sp_p5210_node_name(this_library_node_name2));
/// assert!(!is_valid_string_afipia_sp_p5210_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_afipia_sp_p5210_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1429916"]),
        None,
        Some("."),
        Some("X566_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geobacillus sp. G1w1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1430331.EP10_00055";
/// let this_library_node_name2 = "1430331.EP10_19050";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geobacillus_sp_g1w1_node_name(this_library_node_name1));
/// assert!(is_valid_string_geobacillus_sp_g1w1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geobacillus_sp_g1w1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geobacillus_sp_g1w1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1430331"]),
        None,
        Some("."),
        Some("EP10_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Magnetospirillum gryphiswaldense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1430440.MGMSRv2_0001";
/// let this_library_node_name2 = "1430440.MGMSRv2_4261";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_magnetospirillum_gryphiswaldense_node_name(this_library_node_name1));
/// assert!(is_valid_string_magnetospirillum_gryphiswaldense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_magnetospirillum_gryphiswaldense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_magnetospirillum_gryphiswaldense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1430440"]),
        None,
        Some("."),
        Some("MGMSRv2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium etli mimosae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1432050.IE4771_CH00001";
/// let this_library_node_name2 = "1432050.IE4771_PA00229";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_etli_mimosae_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_etli_mimosae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_etli_mimosae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_etli_mimosae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1432050"]),
        None,
        Some("."),
        Some("IE4771_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Komagataeibacter rhaeticus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1432055.GLUCORHAEAF1_00005";
/// let this_library_node_name2 = "1432055.GLUCORHAEAF1_19415";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_komagataeibacter_rhaeticus_node_name(this_library_node_name1));
/// assert!(is_valid_string_komagataeibacter_rhaeticus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_komagataeibacter_rhaeticus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_komagataeibacter_rhaeticus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1432055"]),
        None,
        Some("."),
        Some("GLUCORHAEAF1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mannheimia varigena USMARC1261 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1432056.X781_10";
/// let this_library_node_name2 = "1432056.X781_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mannheimia_varigena_usmarc1261_node_name(this_library_node_name1));
/// assert!(is_valid_string_mannheimia_varigena_usmarc1261_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mannheimia_varigena_usmarc1261_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mannheimia_varigena_usmarc1261_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1432056"]),
        None,
        Some("."),
        Some("X781_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rikenellaceae bacterium M3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1433126.BN938_0001";
/// let this_library_node_name2 = "1433126.BN938_3060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rikenellaceae_bacterium_m3_node_name(this_library_node_name1));
/// assert!(is_valid_string_rikenellaceae_bacterium_m3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rikenellaceae_bacterium_m3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rikenellaceae_bacterium_m3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1433126"]),
        None,
        Some("."),
        Some("BN938_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mannheimia varigena USMARC1296 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1433287.X808_10";
/// let this_library_node_name2 = "1433287.X808_9990";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mannheimia_varigena_usmarc1296_node_name(this_library_node_name1));
/// assert!(is_valid_string_mannheimia_varigena_usmarc1296_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mannheimia_varigena_usmarc1296_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mannheimia_varigena_usmarc1296_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1433287"]),
        None,
        Some("."),
        Some("X808_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dyadobacter tibetensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1434325.AZQN01000001_gene1";
/// let this_library_node_name2 = "1434325.AZQN01000033_gene1432";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dyadobacter_tibetensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_dyadobacter_tibetensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dyadobacter_tibetensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dyadobacter_tibetensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1434325"]),
        None,
        Some("."),
        Some("AZQN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia pseudomallei ABCPW111 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1434929.X946_1";
/// let this_library_node_name2 = "1434929.X946_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_pseudomallei_abcpw111_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_pseudomallei_abcpw111_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_pseudomallei_abcpw111_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_pseudomallei_abcpw111_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1434929"]),
        None,
        Some("."),
        Some("X946_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium moukalabense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1435051.BMOU_0001";
/// let this_library_node_name2 = "1435051.BMOU_2124";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_moukalabense_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_moukalabense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_moukalabense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_moukalabense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1435051"]),
        None,
        Some("."),
        Some("BMOU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus pyridinivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1435356.Y013_00020";
/// let this_library_node_name2 = "1435356.Y013_26495";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_pyridinivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_pyridinivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_pyridinivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_pyridinivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1435356"]),
        None,
        Some("."),
        Some("Y013_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Criblamydia sequanensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437425.CSEC_0001";
/// let this_library_node_name2 = "1437425.CSEC_2469";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_criblamydia_sequanensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_criblamydia_sequanensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_criblamydia_sequanensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_criblamydia_sequanensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437425"]),
        None,
        Some("."),
        Some("CSEC_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ochrobactrum rhizosphaerae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437448.AZRT01000001_gene1071";
/// let this_library_node_name2 = "1437448.AZRT01000198_gene3574";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ochrobactrum_rhizosphaerae_node_name(this_library_node_name1));
/// assert!(is_valid_string_ochrobactrum_rhizosphaerae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ochrobactrum_rhizosphaerae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ochrobactrum_rhizosphaerae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437448"]),
        None,
        Some("."),
        Some("AZRT01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium pullorum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437600.JDUI01000001_gene384";
/// let this_library_node_name2 = "1437600.JDUI01000038_gene249";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_pullorum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_pullorum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_pullorum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_pullorum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437600"]),
        None,
        Some("."),
        Some("JDUI010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium mongoliense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437603.BMON_0001";
/// let this_library_node_name2 = "1437603.BMON_3000";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_mongoliense_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_mongoliense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_mongoliense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_mongoliense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437603"]),
        None,
        Some("."),
        Some("BMON_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium actinocoloniiforme nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437605.BACT_0001";
/// let this_library_node_name2 = "1437605.BACT_3000";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_actinocoloniiforme_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_actinocoloniiforme_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_actinocoloniiforme_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_actinocoloniiforme_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437605"]),
        None,
        Some("."),
        Some("BACT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium bohemicum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437606.BBOH_0001";
/// let this_library_node_name2 = "1437606.BBOH_1669";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_bohemicum_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_bohemicum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_bohemicum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_bohemicum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437606"]),
        None,
        Some("."),
        Some("BBOH_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium biavatii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437608.BBIA_0001";
/// let this_library_node_name2 = "1437608.BBIA_3019";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_biavatii_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_biavatii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_biavatii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_biavatii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437608"]),
        None,
        Some("."),
        Some("BBIA_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium callitrichos nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437609.BCAL_0001";
/// let this_library_node_name2 = "1437609.BCAL_3003";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_callitrichos_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_callitrichos_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_callitrichos_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_callitrichos_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437609"]),
        None,
        Some("."),
        Some("BCAL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bifidobacterium reuteri nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437610.BREU_0001";
/// let this_library_node_name2 = "1437610.BREU_8003";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bifidobacterium_reuteri_node_name(this_library_node_name1));
/// assert!(is_valid_string_bifidobacterium_reuteri_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bifidobacterium_reuteri_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bifidobacterium_reuteri_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437610"]),
        None,
        Some("."),
        Some("BREU_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Castellaniella defragrans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437824.BN940_00001";
/// let this_library_node_name2 = "1437824.BN940_18331";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_castellaniella_defragrans_node_name(this_library_node_name1));
/// assert!(is_valid_string_castellaniella_defragrans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_castellaniella_defragrans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_castellaniella_defragrans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437824"]),
        None,
        Some("."),
        Some("BN940_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas nitroreducens HBP1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1437882.AZRU01000001_gene1973";
/// let this_library_node_name2 = "1437882.AZRU01000212_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_nitroreducens_hbp1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_nitroreducens_hbp1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_nitroreducens_hbp1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_nitroreducens_hbp1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1437882"]),
        None,
        Some("."),
        Some("AZRU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. BAY1663 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1439940.BAY1663_00001";
/// let this_library_node_name2 = "1439940.BAY1663_05110";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_bay1663_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_bay1663_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_bay1663_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_bay1663_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1439940"]),
        None,
        Some("."),
        Some("BAY1663_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Escherichia albertii KF1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1440052.EAKF1_ch0001c";
/// let this_library_node_name2 = "1440052.EAKF1_ch4543c";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_escherichia_albertii_kf1_node_name(this_library_node_name1));
/// assert!(is_valid_string_escherichia_albertii_kf1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_escherichia_albertii_kf1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_escherichia_albertii_kf1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1440052"]),
        None,
        Some("."),
        Some("EAKF1_ch"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces scopuliridis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1440053.JOEI01000001_gene1456";
/// let this_library_node_name2 = "1440053.JOEI01000115_gene4849";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_scopuliridis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_scopuliridis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_scopuliridis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_scopuliridis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1440053"]),
        None,
        Some("."),
        Some("JOEI01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium aromaticivorans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1440774.Y900_000015";
/// let this_library_node_name2 = "1440774.Y900_031150";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_aromaticivorans_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_aromaticivorans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_aromaticivorans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_aromaticivorans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1440774"]),
        None,
        Some("."),
        Some("Y900_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas cichorii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1441629.PCH70_00010";
/// let this_library_node_name2 = "1441629.PCH70_51740";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_cichorii_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_cichorii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_cichorii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_cichorii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1441629"]),
        None,
        Some("."),
        Some("PCH70_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia fonticola RB25 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1441930.Z042_00005";
/// let this_library_node_name2 = "1441930.Z042_25265";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_fonticola_rb25_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_fonticola_rb25_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_fonticola_rb25_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_fonticola_rb25_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1441930"]),
        None,
        Some("."),
        Some("Z042_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arcobacter cibarius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1442598.JABW01000001_gene1781";
/// let this_library_node_name2 = "1442598.JABW01000044_gene2197";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arcobacter_cibarius_node_name(this_library_node_name1));
/// assert!(is_valid_string_arcobacter_cibarius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arcobacter_cibarius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arcobacter_cibarius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1442598"]),
        None,
        Some("."),
        Some("JABW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Luteimonas huabeiensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1442599.JAAN01000001_gene2147";
/// let this_library_node_name2 = "1442599.JAAN01000086_gene2678";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_luteimonas_huabeiensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_luteimonas_huabeiensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_luteimonas_huabeiensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_luteimonas_huabeiensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1442599"]),
        None,
        Some("."),
        Some("JAAN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfitobacter guttiformis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1443111.JASG01000001_gene10";
/// let this_library_node_name2 = "1443111.JASG01000004_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfitobacter_guttiformis_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfitobacter_guttiformis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfitobacter_guttiformis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfitobacter_guttiformis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1443111"]),
        None,
        Some("."),
        Some("JASG0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Yersinia enterocolitica LC20 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1443113.LC20_00001";
/// let this_library_node_name2 = "1443113.LC20_06264";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_yersinia_enterocolitica_lc20_node_name(this_library_node_name1));
/// assert!(is_valid_string_yersinia_enterocolitica_lc20_node_name(this_library_node_name2));
/// assert!(!is_valid_string_yersinia_enterocolitica_lc20_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_yersinia_enterocolitica_lc20_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1443113"]),
        None,
        Some("."),
        Some("LC20_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium novyi B NCTC9691 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1443122.Z958_00015";
/// let this_library_node_name2 = "1443122.Z958_p0074";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_novyi_b_nctc9691_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_novyi_b_nctc9691_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_novyi_b_nctc9691_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_novyi_b_nctc9691_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1443122"]),
        None,
        Some("."),
        Some("Z958_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium botulinum CD BKT12695 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1443125.Z962_00005";
/// let this_library_node_name2 = "1443125.Z962_p0081";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_botulinum_cd_bkt12695_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_botulinum_cd_bkt12695_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_botulinum_cd_bkt12695_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_botulinum_cd_bkt12695_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1443125"]),
        None,
        Some("."),
        Some("Z962_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquimarina macrocephali nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1443665.JACA01000001_gene2522";
/// let this_library_node_name2 = "1443665.JACA01000169_gene1499";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquimarina_macrocephali_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquimarina_macrocephali_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquimarina_macrocephali_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquimarina_macrocephali_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1443665"]),
        None,
        Some("."),
        Some("JACA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sporolactobacillus terrae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1444306.JFZC01000004_gene1598";
/// let this_library_node_name2 = "1444306.JFZC01000101_gene1278";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sporolactobacillus_terrae_node_name(this_library_node_name1));
/// assert!(is_valid_string_sporolactobacillus_terrae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sporolactobacillus_terrae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sporolactobacillus_terrae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1444306"]),
        None,
        Some("."),
        Some("JFZC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Brevibacillus borstelensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1444309.JAQG01000001_gene4997";
/// let this_library_node_name2 = "1444309.JAQG01000191_gene668";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_brevibacillus_borstelensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_brevibacillus_borstelensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_brevibacillus_borstelensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_brevibacillus_borstelensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1444309"]),
        None,
        Some("."),
        Some("JAQG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus flexus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1444310.JANV01000001_gene4365";
/// let this_library_node_name2 = "1444310.JANV01000206_gene747";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_flexus_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_flexus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_flexus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_flexus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1444310"]),
        None,
        Some("."),
        Some("JANV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydia sp. Diamant nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1444711.CCJF01000001_gene100";
/// let this_library_node_name2 = "1444711.CCJF01000005_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydia_sp_diamant_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydia_sp_diamant_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydia_sp_diamant_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydia_sp_diamant_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1444711"]),
        None,
        Some("."),
        Some("CCJF0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlamydia sp. Rubis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1444712.BN1013_00002";
/// let this_library_node_name2 = "1444712.BN1013_02491";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlamydia_sp_rubis_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlamydia_sp_rubis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlamydia_sp_rubis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlamydia_sp_rubis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1444712"]),
        None,
        Some("."),
        Some("BN1013_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xylella fastidiosa PLS229 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1444770.AF72_00005";
/// let this_library_node_name2 = "1444770.AF72_13810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xylella_fastidiosa_pls229_node_name(this_library_node_name1));
/// assert!(is_valid_string_xylella_fastidiosa_pls229_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xylella_fastidiosa_pls229_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xylella_fastidiosa_pls229_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1444770"]),
        None,
        Some("."),
        Some("AF72_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sciscionella sp. SE31 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1445613.JALM01000001_gene3154";
/// let this_library_node_name2 = "1445613.JALM01000217_gene6888";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sciscionella_sp_se31_node_name(this_library_node_name1));
/// assert!(is_valid_string_sciscionella_sp_se31_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sciscionella_sp_se31_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sciscionella_sp_se31_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1445613"]),
        None,
        Some("."),
        Some("JALM01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus yeei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1446473.JHWH01000001_gene1000";
/// let this_library_node_name2 = "1446473.JHWH01000072_gene2101";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_yeei_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_yeei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_yeei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_yeei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1446473"]),
        None,
        Some("."),
        Some("JHWH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aeromonas hydrophila YL17 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1448139.AI20_00005";
/// let this_library_node_name2 = "1448139.AI20_21995";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aeromonas_hydrophila_yl17_node_name(this_library_node_name1));
/// assert!(is_valid_string_aeromonas_hydrophila_yl17_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aeromonas_hydrophila_yl17_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aeromonas_hydrophila_yl17_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1448139"]),
        None,
        Some("."),
        Some("AI20_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Tomitella biformata nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1448389.BAVQ01000001_gene2823";
/// let this_library_node_name2 = "1448389.BAVQ01000113_gene1116";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_tomitella_biformata_node_name(this_library_node_name1));
/// assert!(is_valid_string_tomitella_biformata_node_name(this_library_node_name2));
/// assert!(!is_valid_string_tomitella_biformata_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_tomitella_biformata_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1448389"]),
        None,
        Some("."),
        Some("BAVQ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter sp. CIT045 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1448857.JFAP01000001_gene1000";
/// let this_library_node_name2 = "1448857.JFAP01000021_gene5";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_sp_cit045_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_sp_cit045_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_sp_cit045_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_sp_cit045_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1448857"]),
        None,
        Some("."),
        Some("JFAP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halobellus rufus nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1448860.BBJO01000001_gene2828";
/// let this_library_node_name2 = "1448860.BBJO01000081_gene1491";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halobellus_rufus_node_name(this_library_node_name1));
/// assert!(is_valid_string_halobellus_rufus_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halobellus_rufus_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halobellus_rufus_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1448860"]),
        None,
        Some("."),
        Some("BBJO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthrobacter sp. UNC362MFTsu51 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449044.JMLE01000001_gene3693";
/// let this_library_node_name2 = "1449044.JMLE01000068_gene372";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthrobacter_sp_unc362mftsu51_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthrobacter_sp_unc362mftsu51_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthrobacter_sp_unc362mftsu51_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthrobacter_sp_unc362mftsu51_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449044"]),
        None,
        Some("."),
        Some("JMLE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mycobacterium sp. UNC280MFTsu51 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449048.JQKU01000001_gene1873";
/// let this_library_node_name2 = "1449048.JQKU01000048_gene3988";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mycobacterium_sp_unc280mftsu51_node_name(this_library_node_name1));
/// assert!(is_valid_string_mycobacterium_sp_unc280mftsu51_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mycobacterium_sp_unc280mftsu51_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mycobacterium_sp_unc280mftsu51_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449048"]),
        None,
        Some("."),
        Some("JQKU010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caulobacter sp. UNC358MFTsu51 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449049.JONW01000001_gene3323";
/// let this_library_node_name2 = "1449049.JONW01000013_gene4819";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caulobacter_sp_unc358mftsu51_node_name(this_library_node_name1));
/// assert!(is_valid_string_caulobacter_sp_unc358mftsu51_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caulobacter_sp_unc358mftsu51_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caulobacter_sp_unc358mftsu51_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449049"]),
        None,
        Some("."),
        Some("JONW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. KNHs205 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449050.JNLE01000001_gene3934";
/// let this_library_node_name2 = "1449050.JNLE01000006_gene5335";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_knhs205_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_knhs205_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_knhs205_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_knhs205_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449050"]),
        None,
        Some("."),
        Some("JNLE0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium sp. UNCCL10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449058.JQKT01000001_gene281";
/// let this_library_node_name2 = "1449058.JQKT01000017_gene2817";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_sp_unccl10_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_sp_unccl10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_sp_unccl10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_sp_unccl10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449058"]),
        None,
        Some("."),
        Some("JQKT010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. UNC451MF nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449063.JMLS01000001_gene4045";
/// let this_library_node_name2 = "1449063.JMLS01000076_gene6229";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_unc451mf_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_unc451mf_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_unc451mf_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_unc451mf_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449063"]),
        None,
        Some("."),
        Some("JMLS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Phyllobacterium sp. UNC302MFCol52 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449065.JMLL01000001_gene4000";
/// let this_library_node_name2 = "1449065.JMLL01000018_gene1991";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_phyllobacterium_sp_unc302mfcol52_node_name(this_library_node_name1));
/// assert!(is_valid_string_phyllobacterium_sp_unc302mfcol52_node_name(this_library_node_name2));
/// assert!(!is_valid_string_phyllobacterium_sp_unc302mfcol52_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_phyllobacterium_sp_unc302mfcol52_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449065"]),
        None,
        Some("."),
        Some("JMLL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus sp. UNC23MFCrub11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449068.JMLQ01000001_gene1";
/// let this_library_node_name2 = "1449068.JMLQ01000023_gene4304";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_sp_unc23mfcrub11_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_sp_unc23mfcrub11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_sp_unc23mfcrub11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_sp_unc23mfcrub11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449068"]),
        None,
        Some("."),
        Some("JMLQ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodococcus sp. UNC363MFTsu51 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449069.JMLO01000001_gene1578";
/// let this_library_node_name2 = "1449069.JMLO01000071_gene3158";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodococcus_sp_unc363mftsu51_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodococcus_sp_unc363mftsu51_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodococcus_sp_unc363mftsu51_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodococcus_sp_unc363mftsu51_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449069"]),
        None,
        Some("."),
        Some("JMLO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. UNC305MFCol52 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449076.JOOE01000001_gene1633";
/// let this_library_node_name2 = "1449076.JOOE01000007_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_unc305mfcol52_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_unc305mfcol52_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_unc305mfcol52_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_unc305mfcol52_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449076"]),
        None,
        Some("."),
        Some("JOOE0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus sp. YIM77409 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449080.JQMV01000001_gene1";
/// let this_library_node_name2 = "1449080.JQMV01000006_gene2284";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_sp_yim77409_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_sp_yim77409_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_sp_yim77409_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_sp_yim77409_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449080"]),
        None,
        Some("."),
        Some("JQMV0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridiales bacterium DRI13 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449126.JQKL01000001_gene1304";
/// let this_library_node_name2 = "1449126.JQKL01000106_gene2444";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridiales_bacterium_dri13_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridiales_bacterium_dri13_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridiales_bacterium_dri13_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridiales_bacterium_dri13_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449126"]),
        None,
        Some("."),
        Some("JQKL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carnobacterium alterfunditum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449335.JQLG01000001_gene39";
/// let this_library_node_name2 = "1449335.JQLG01000007_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carnobacterium_alterfunditum_node_name(this_library_node_name1));
/// assert!(is_valid_string_carnobacterium_alterfunditum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carnobacterium_alterfunditum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carnobacterium_alterfunditum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449335"]),
        None,
        Some("."),
        Some("JQLG0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carnobacterium divergens nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449336.JQLO01000001_gene1";
/// let this_library_node_name2 = "1449336.JQLO01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carnobacterium_divergens_node_name(this_library_node_name1));
/// assert!(is_valid_string_carnobacterium_divergens_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carnobacterium_divergens_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carnobacterium_divergens_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449336"]),
        None,
        Some("."),
        Some("JQLO01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carnobacterium funditum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449337.JQLL01000001_gene100";
/// let this_library_node_name2 = "1449337.JQLL01000002_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carnobacterium_funditum_node_name(this_library_node_name1));
/// assert!(is_valid_string_carnobacterium_funditum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carnobacterium_funditum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carnobacterium_funditum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449337"]),
        None,
        Some("."),
        Some("JQLL0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carnobacterium gallinarum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449338.JQLU01000001_gene913";
/// let this_library_node_name2 = "1449338.JQLU01000005_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carnobacterium_gallinarum_node_name(this_library_node_name1));
/// assert!(is_valid_string_carnobacterium_gallinarum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carnobacterium_gallinarum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carnobacterium_gallinarum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449338"]),
        None,
        Some("."),
        Some("JQLU0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carnobacterium mobile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449342.JQMR01000001_gene100";
/// let this_library_node_name2 = "1449342.JQMR01000006_gene2449";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carnobacterium_mobile_node_name(this_library_node_name1));
/// assert!(is_valid_string_carnobacterium_mobile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carnobacterium_mobile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carnobacterium_mobile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449342"]),
        None,
        Some("."),
        Some("JQMR0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Carnobacterium pleistocenium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449343.JQLQ01000001_gene1";
/// let this_library_node_name2 = "1449343.JQLQ01000004_gene20";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_carnobacterium_pleistocenium_node_name(this_library_node_name1));
/// assert!(is_valid_string_carnobacterium_pleistocenium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_carnobacterium_pleistocenium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_carnobacterium_pleistocenium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449343"]),
        None,
        Some("."),
        Some("JQLQ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter rodentium nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449345.JHWC01000001_gene10";
/// let this_library_node_name2 = "1449345.JHWC01000029_gene2";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_rodentium_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_rodentium_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_rodentium_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_rodentium_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449345"]),
        None,
        Some("."),
        Some("JHWC010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kitasatospora azatica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449346.JQMO01000001_gene6988";
/// let this_library_node_name2 = "1449346.JQMO01000003_gene6987";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kitasatospora_azatica_node_name(this_library_node_name1));
/// assert!(is_valid_string_kitasatospora_azatica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kitasatospora_azatica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kitasatospora_azatica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449346"]),
        None,
        Some("."),
        Some("JQMO0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kitasatospora mediocidica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449347.JQLN01000001_gene1";
/// let this_library_node_name2 = "1449347.JQLN01000007_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kitasatospora_mediocidica_node_name(this_library_node_name1));
/// assert!(is_valid_string_kitasatospora_mediocidica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kitasatospora_mediocidica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kitasatospora_mediocidica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449347"]),
        None,
        Some("."),
        Some("JQLN0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseivivax halodurans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449350.OCH239_00005";
/// let this_library_node_name2 = "1449350.OCH239_22355";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseivivax_halodurans_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseivivax_halodurans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseivivax_halodurans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseivivax_halodurans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449350"]),
        None,
        Some("."),
        Some("OCH239_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Roseivivax isoporae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449351.RISW2_00005";
/// let this_library_node_name2 = "1449351.RISW2_23980";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_roseivivax_isoporae_node_name(this_library_node_name1));
/// assert!(is_valid_string_roseivivax_isoporae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_roseivivax_isoporae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_roseivivax_isoporae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449351"]),
        None,
        Some("."),
        Some("RISW2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptacidiphilus oryzae nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449353.JQMQ01000001_gene1";
/// let this_library_node_name2 = "1449353.JQMQ01000006_gene6772";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptacidiphilus_oryzae_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptacidiphilus_oryzae_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptacidiphilus_oryzae_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptacidiphilus_oryzae_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449353"]),
        None,
        Some("."),
        Some("JQMQ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces yeochonensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449355.JQNR01000001_gene2090";
/// let this_library_node_name2 = "1449355.JQNR01000006_gene2170";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_yeochonensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_yeochonensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_yeochonensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_yeochonensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449355"]),
        None,
        Some("."),
        Some("JQNR0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thermus tengchongensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449357.JQLK01000001_gene1";
/// let this_library_node_name2 = "1449357.JQLK01000005_gene2484";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thermus_tengchongensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_thermus_tengchongensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thermus_tengchongensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thermus_tengchongensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449357"]),
        None,
        Some("."),
        Some("JQLK0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Kutzneria albida nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1449976.KALB_1";
/// let this_library_node_name2 = "1449976.KALB_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_kutzneria_albida_node_name(this_library_node_name1));
/// assert!(is_valid_string_kutzneria_albida_node_name(this_library_node_name2));
/// assert!(!is_valid_string_kutzneria_albida_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_kutzneria_albida_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1449976"]),
        None,
        Some("."),
        Some("KALB_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium succinicans nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1450525.JATV01000001_gene2458";
/// let this_library_node_name2 = "1450525.JATV01000047_gene2310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_succinicans_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_succinicans_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_succinicans_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_succinicans_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1450525"]),
        None,
        Some("."),
        Some("JATV010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. TS2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1450694.BTS2_0001";
/// let this_library_node_name2 = "1450694.BTS2_4110";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_ts2_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_ts2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_ts2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_ts2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1450694"]),
        None,
        Some("."),
        Some("BTS2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium falsenii nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1451189.CFAL_00005";
/// let this_library_node_name2 = "1451189.CFAL_12135";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_falsenii_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_falsenii_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_falsenii_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_falsenii_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1451189"]),
        None,
        Some("."),
        Some("CFAL_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium sp. MRS1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1451261.AS96_00005";
/// let this_library_node_name2 = "1451261.AS96_15115";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_sp_mrs1_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_sp_mrs1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_sp_mrs1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_sp_mrs1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1451261"]),
        None,
        Some("."),
        Some("AS96_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium sp. CrK32 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1452535.JARD01000002_gene1502";
/// let this_library_node_name2 = "1452535.JARD01000030_gene1216";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_sp_crk32_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_sp_crk32_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_sp_crk32_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_sp_crk32_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1452535"]),
        None,
        Some("."),
        Some("JARD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbacterium sp. CrK20 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1452536.JARE01000001_gene1000";
/// let this_library_node_name2 = "1452536.JARE01000082_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbacterium_sp_crk20_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbacterium_sp_crk20_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbacterium_sp_crk20_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbacterium_sp_crk20_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1452536"]),
        None,
        Some("."),
        Some("JARE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. RL nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1452718.JBOY01000001_gene496";
/// let this_library_node_name2 = "1452718.JBOY01000228_gene445";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_rl_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_rl_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_rl_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_rl_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1452718"]),
        None,
        Some("."),
        Some("JBOY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hafnia alvei nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1453496.AT03_00020";
/// let this_library_node_name2 = "1453496.AT03_21495";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hafnia_alvei_node_name(this_library_node_name1));
/// assert!(is_valid_string_hafnia_alvei_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hafnia_alvei_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hafnia_alvei_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1453496"]),
        None,
        Some("."),
        Some("AT03_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium aquatile nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1453498.LG45_00005";
/// let this_library_node_name2 = "1453498.LG45_16440";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_aquatile_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_aquatile_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_aquatile_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_aquatile_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1453498"]),
        None,
        Some("."),
        Some("LG45_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Schleiferia thermophila nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1453500.AT05_00005";
/// let this_library_node_name2 = "1453500.AT05_11955";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_schleiferia_thermophila_node_name(this_library_node_name1));
/// assert!(is_valid_string_schleiferia_thermophila_node_name(this_library_node_name2));
/// assert!(!is_valid_string_schleiferia_thermophila_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_schleiferia_thermophila_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1453500"]),
        None,
        Some("."),
        Some("AT05_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Microbulbifer sp. HZ11 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1453501.JELR01000001_gene1797";
/// let this_library_node_name2 = "1453501.JELR01000007_gene38";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_microbulbifer_sp_hz11_node_name(this_library_node_name1));
/// assert!(is_valid_string_microbulbifer_sp_hz11_node_name(this_library_node_name2));
/// assert!(!is_valid_string_microbulbifer_sp_hz11_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_microbulbifer_sp_hz11_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1453501"]),
        None,
        Some("."),
        Some("JELR0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas pseudoalcaligenes AD6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1453503.AU05_00005";
/// let this_library_node_name2 = "1453503.AU05_25500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_pseudoalcaligenes_ad6_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_pseudoalcaligenes_ad6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_pseudoalcaligenes_ad6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_pseudoalcaligenes_ad6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1453503"]),
        None,
        Some("."),
        Some("AU05_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium chungangense nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1453505.JASY01000001_gene3156";
/// let this_library_node_name2 = "1453505.JASY01000046_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_chungangense_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_chungangense_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_chungangense_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_chungangense_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1453505"]),
        None,
        Some("."),
        Some("JASY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Accumulibacter sp. BA93 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1454004.AW11_00001";
/// let this_library_node_name2 = "1454004.AW11_04087";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_accumulibacter_sp_ba93_node_name(this_library_node_name1));
/// assert!(is_valid_string_accumulibacter_sp_ba93_node_name(this_library_node_name2));
/// assert!(!is_valid_string_accumulibacter_sp_ba93_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_accumulibacter_sp_ba93_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1454004"]),
        None,
        Some("."),
        Some("AW11_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pedobacter borealis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1454007.JAUG01000001_gene3562";
/// let this_library_node_name2 = "1454007.JAUG01000217_gene4555";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pedobacter_borealis_node_name(this_library_node_name1));
/// assert!(is_valid_string_pedobacter_borealis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pedobacter_borealis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pedobacter_borealis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1454007"]),
        None,
        Some("."),
        Some("JAUG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cellulomonas sp. HZM nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1454010.JEOE01000001_gene533";
/// let this_library_node_name2 = "1454010.JEOE01000077_gene1956";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cellulomonas_sp_hzm_node_name(this_library_node_name1));
/// assert!(is_valid_string_cellulomonas_sp_hzm_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cellulomonas_sp_hzm_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cellulomonas_sp_hzm_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1454010"]),
        None,
        Some("."),
        Some("JEOE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Photobacterium phosphoreum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1454202.PPBDW_100002___1";
/// let this_library_node_name2 = "1454202.PPBDW_91021___1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_photobacterium_phosphoreum_node_name(this_library_node_name1));
/// assert!(is_valid_string_photobacterium_phosphoreum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_photobacterium_phosphoreum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_photobacterium_phosphoreum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1454202"]),
        None,
        Some("."),
        Some("PPBDW_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haladaptatus cibarius nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1455608.JDTH01000001_gene2820";
/// let this_library_node_name2 = "1455608.JDTH01000013_gene9";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haladaptatus_cibarius_node_name(this_library_node_name1));
/// assert!(is_valid_string_haladaptatus_cibarius_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haladaptatus_cibarius_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haladaptatus_cibarius_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1455608"]),
        None,
        Some("."),
        Some("JDTH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halapricum salinum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1457250.BBMO01000001_gene1";
/// let this_library_node_name2 = "1457250.BBMO01000003_gene3311";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halapricum_salinum_node_name(this_library_node_name1));
/// assert!(is_valid_string_halapricum_salinum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halapricum_salinum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halapricum_salinum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1457250"]),
        None,
        Some("."),
        Some("BBMO0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acetobacter aceti 1023 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1457393.AZ09_00005";
/// let this_library_node_name2 = "1457393.AZ09_15060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acetobacter_aceti_1023_node_name(this_library_node_name1));
/// assert!(is_valid_string_acetobacter_aceti_1023_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acetobacter_aceti_1023_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acetobacter_aceti_1023_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1457393"]),
        None,
        Some("."),
        Some("AZ09_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hylemonella gracilis Niagara nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1458275.AZ34_00005";
/// let this_library_node_name2 = "1458275.AZ34_17760";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hylemonella_gracilis_niagara_node_name(this_library_node_name1));
/// assert!(is_valid_string_hylemonella_gracilis_niagara_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hylemonella_gracilis_niagara_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hylemonella_gracilis_niagara_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1458275"]),
        None,
        Some("."),
        Some("AZ34_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sp. MP1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1458357.BG58_00010";
/// let this_library_node_name2 = "1458357.BG58_41775";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sp_mp1_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sp_mp1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sp_mp1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sp_mp1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1458357"]),
        None,
        Some("."),
        Some("BG58_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Comamonadaceae bacterium H1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1458427.BAWN01000001_gene1";
/// let this_library_node_name2 = "1458427.BAWN01000094_gene2223";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_comamonadaceae_bacterium_h1_node_name(this_library_node_name1));
/// assert!(is_valid_string_comamonadaceae_bacterium_h1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_comamonadaceae_bacterium_h1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_comamonadaceae_bacterium_h1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1458427"]),
        None,
        Some("."),
        Some("BAWN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lachnospiraceae bacterium AC2029 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1458462.JNLK01000001_gene1";
/// let this_library_node_name2 = "1458462.JNLK01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lachnospiraceae_bacterium_ac2029_node_name(this_library_node_name1));
/// assert!(is_valid_string_lachnospiraceae_bacterium_ac2029_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lachnospiraceae_bacterium_ac2029_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lachnospiraceae_bacterium_ac2029_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1458462"]),
        None,
        Some("."),
        Some("JNLK01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Nitrososphaera evergladensis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1459636.NTE_00001";
/// let this_library_node_name2 = "1459636.NTE_03555";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_nitrososphaera_evergladensis_node_name(this_library_node_name1));
/// assert!(is_valid_string_nitrososphaera_evergladensis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_nitrososphaera_evergladensis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_nitrososphaera_evergladensis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1459636"]),
        None,
        Some("."),
        Some("NTE_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geomicrobium sp. JCM19037 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1460634.JCM19037_10";
/// let this_library_node_name2 = "1460634.JCM19037_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geomicrobium_sp_jcm19037_node_name(this_library_node_name1));
/// assert!(is_valid_string_geomicrobium_sp_jcm19037_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geomicrobium_sp_jcm19037_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geomicrobium_sp_jcm19037_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1460634"]),
        None,
        Some("."),
        Some("JCM19037_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Geomicrobium sp. JCM19038 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1460635.JCM19038_1";
/// let this_library_node_name2 = "1460635.JCM19038_998";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_geomicrobium_sp_jcm19038_node_name(this_library_node_name1));
/// assert!(is_valid_string_geomicrobium_sp_jcm19038_node_name(this_library_node_name2));
/// assert!(!is_valid_string_geomicrobium_sp_jcm19038_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_geomicrobium_sp_jcm19038_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1460635"]),
        None,
        Some("."),
        Some("JCM19038_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. JCM19046 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1460640.JCM19046_1";
/// let this_library_node_name2 = "1460640.JCM19046_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_jcm19046_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_jcm19046_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_jcm19046_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_jcm19046_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1460640"]),
        None,
        Some("."),
        Some("JCM19046_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Weeksella sp. FF8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1461577.CCMH01000001_gene268";
/// let this_library_node_name2 = "1461577.CCMH01000054_gene731";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_weeksella_sp_ff8_node_name(this_library_node_name1));
/// assert!(is_valid_string_weeksella_sp_ff8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_weeksella_sp_ff8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_weeksella_sp_ff8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1461577"]),
        None,
        Some("."),
        Some("CCMH010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Haemophilus sp. FF7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1461579.CCNK01000001_gene1";
/// let this_library_node_name2 = "1461579.CCNK01000045_gene2277";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_haemophilus_sp_ff7_node_name(this_library_node_name1));
/// assert!(is_valid_string_haemophilus_sp_ff7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_haemophilus_sp_ff7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_haemophilus_sp_ff7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1461579"]),
        None,
        Some("."),
        Some("CCNK010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. JCE nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1461580.CCAS010000001_gene1";
/// let this_library_node_name2 = "1461580.CCAS010000148_gene4632";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_jce_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_jce_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_jce_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_jce_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1461580"]),
        None,
        Some("."),
        Some("CCAS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Jeotgalicoccus sp. 13MG44air nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1461582.BN1048_00008";
/// let this_library_node_name2 = "1461582.BN1048_02284";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_jeotgalicoccus_sp_13mg44air_node_name(this_library_node_name1));
/// assert!(is_valid_string_jeotgalicoccus_sp_13mg44air_node_name(this_library_node_name2));
/// assert!(!is_valid_string_jeotgalicoccus_sp_13mg44air_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_jeotgalicoccus_sp_13mg44air_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1461582"]),
        None,
        Some("."),
        Some("BN1048_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actibacterium atlanticum nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1461693.ATO10_00010";
/// let this_library_node_name2 = "1461693.ATO10_15760";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actibacterium_atlanticum_node_name(this_library_node_name1));
/// assert!(is_valid_string_actibacterium_atlanticum_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actibacterium_atlanticum_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actibacterium_atlanticum_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1461693"]),
        None,
        Some("."),
        Some("ATO10_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanicola sp. 22IIS11g nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1461694.ATO9_00005";
/// let this_library_node_name2 = "1461694.ATO9_23675";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanicola_sp_22iis11g_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanicola_sp_22iis11g_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanicola_sp_22iis11g_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanicola_sp_22iis11g_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1461694"]),
        None,
        Some("."),
        Some("ATO9_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Virgibacillus sp. Vm5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1462526.BN990_00001";
/// let this_library_node_name2 = "1462526.BN990_04519";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_virgibacillus_sp_vm5_node_name(this_library_node_name1));
/// assert!(is_valid_string_virgibacillus_sp_vm5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_virgibacillus_sp_vm5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_virgibacillus_sp_vm5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1462526"]),
        None,
        Some("."),
        Some("BN990_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanobacillus sp. S5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1462527.CCDM010000001_gene1706";
/// let this_library_node_name2 = "1462527.CCDM010000012_gene584";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanobacillus_sp_s5_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanobacillus_sp_s5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanobacillus_sp_s5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanobacillus_sp_s5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1462527"]),
        None,
        Some("."),
        Some("CCDM0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Actinosporangium sp. NRRLB3428 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463820.JOGW01000001_gene5207";
/// let this_library_node_name2 = "1463820.JOGW01000074_gene2793";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinosporangium_sp_nrrlb3428_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinosporangium_sp_nrrlb3428_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinosporangium_sp_nrrlb3428_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinosporangium_sp_nrrlb3428_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463820"]),
        None,
        Some("."),
        Some("JOGW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Glycomyces sp. NRRLB16210 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463821.JOGR01000001_gene1229";
/// let this_library_node_name2 = "1463821.JOGR01000031_gene1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_glycomyces_sp_nrrlb16210_node_name(this_library_node_name1));
/// assert!(is_valid_string_glycomyces_sp_nrrlb16210_node_name(this_library_node_name2));
/// assert!(!is_valid_string_glycomyces_sp_nrrlb16210_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_glycomyces_sp_nrrlb16210_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463821"]),
        None,
        Some("."),
        Some("JOGR010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Saccharothrix sp. NRRLB16314 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463825.JNXC01000001_gene5392";
/// let this_library_node_name2 = "1463825.JNXC01000273_gene7917";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_saccharothrix_sp_nrrlb16314_node_name(this_library_node_name1));
/// assert!(is_valid_string_saccharothrix_sp_nrrlb16314_node_name(this_library_node_name2));
/// assert!(!is_valid_string_saccharothrix_sp_nrrlb16314_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_saccharothrix_sp_nrrlb16314_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463825"]),
        None,
        Some("."),
        Some("JNXC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF2580 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463841.JOIR01000001_gene6815";
/// let this_library_node_name2 = "1463841.JOIR01000155_gene1509";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf2580_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf2580_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf2580_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf2580_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463841"]),
        None,
        Some("."),
        Some("JOIR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF2890 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463845.JOIG01000001_gene1353";
/// let this_library_node_name2 = "1463845.JOIG01000055_gene1352";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf2890_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf2890_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf2890_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf2890_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463845"]),
        None,
        Some("."),
        Some("JOIG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF5008 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463853.JOHW01000001_gene5900";
/// let this_library_node_name2 = "1463853.JOHW01000081_gene1152";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf5008_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf5008_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf5008_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf5008_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463853"]),
        None,
        Some("."),
        Some("JOHW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF5053 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463854.JOHT01000001_gene2642";
/// let this_library_node_name2 = "1463854.JOHT01000163_gene5606";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf5053_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf5053_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf5053_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf5053_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463854"]),
        None,
        Some("."),
        Some("JOHT01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF5065 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463855.JOHV01000001_gene1550";
/// let this_library_node_name2 = "1463855.JOHV01000229_gene335";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf5065_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf5065_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf5065_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf5065_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463855"]),
        None,
        Some("."),
        Some("JOHV01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF5123 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463856.JOHY01000001_gene214";
/// let this_library_node_name2 = "1463856.JOHY01000250_gene2516";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf5123_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf5123_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf5123_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf5123_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463856"]),
        None,
        Some("."),
        Some("JOHY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF5126 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463857.JOFZ01000001_gene5261";
/// let this_library_node_name2 = "1463857.JOFZ01000167_gene4072";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf5126_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf5126_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf5126_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf5126_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463857"]),
        None,
        Some("."),
        Some("JOFZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF5135 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463858.JOHR01000001_gene6103";
/// let this_library_node_name2 = "1463858.JOHR01000116_gene2967";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf5135_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf5135_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf5135_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf5135_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463858"]),
        None,
        Some("."),
        Some("JOHR01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF525 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463861.JNXE01000001_gene4873";
/// let this_library_node_name2 = "1463861.JNXE01000242_gene8015";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf525_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf525_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf525_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf525_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463861"]),
        None,
        Some("."),
        Some("JNXE01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF5630 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463864.JOGO01000001_gene1681";
/// let this_library_node_name2 = "1463864.JOGO01000237_gene2597";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf5630_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf5630_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf5630_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf5630_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463864"]),
        None,
        Some("."),
        Some("JOGO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLF6677 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463879.JOHP01000001_gene1405";
/// let this_library_node_name2 = "1463879.JOHP01000188_gene821";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlf6677_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlf6677_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlf6677_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlf6677_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463879"]),
        None,
        Some("."),
        Some("JOHP01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS118 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463881.KL591002_gene4237";
/// let this_library_node_name2 = "1463881.KL591074_gene2588";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls118_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls118_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls118_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls118_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463881"]),
        None,
        Some("."),
        Some("KL5910"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS149 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463885.KL578351_gene4591";
/// let this_library_node_name2 = "1463885.KL578634_gene9132";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls149_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls149_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls149_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls149_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463885"]),
        None,
        Some("."),
        Some("KL578"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS1777 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463887.KL589951_gene4780";
/// let this_library_node_name2 = "1463887.KL590127_gene2270";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls1777_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls1777_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls1777_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls1777_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463887"]),
        None,
        Some("."),
        Some("KL5"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS237 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463895.JODA01000001_gene160";
/// let this_library_node_name2 = "1463895.JODA01000172_gene7966";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls237_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls237_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls237_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls237_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463895"]),
        None,
        Some("."),
        Some("JODA01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS337 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463900.JOIX01000001_gene6212";
/// let this_library_node_name2 = "1463900.JOIX01000228_gene6659";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls337_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls337_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls337_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls337_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463900"]),
        None,
        Some("."),
        Some("JOIX01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS340 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463901.JOIY01000001_gene4760";
/// let this_library_node_name2 = "1463901.JOIY01000161_gene6789";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls340_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls340_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls340_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls340_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463901"]),
        None,
        Some("."),
        Some("JOIY01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS37 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463903.JOIZ01000001_gene100";
/// let this_library_node_name2 = "1463903.JOIZ01000179_gene1750";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls37_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls37_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls37_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls37_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463903"]),
        None,
        Some("."),
        Some("JOIZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS474 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463909.KL585946_gene1225";
/// let this_library_node_name2 = "1463909.KL585991_gene3924";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls474_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls474_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls474_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls474_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463909"]),
        None,
        Some("."),
        Some("KL5859"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS646 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463917.JODC01000001_gene100";
/// let this_library_node_name2 = "1463917.JODC01000163_gene1175";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls646_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls646_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls646_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls646_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463917"]),
        None,
        Some("."),
        Some("JODC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS87 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463920.JOGB01000001_gene3276";
/// let this_library_node_name2 = "1463920.JOGB01000255_gene6191";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls87_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls87_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls87_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls87_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463920"]),
        None,
        Some("."),
        Some("JOGB01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLS920 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463921.JODF01000001_gene3827";
/// let this_library_node_name2 = "1463921.JODF01000197_gene1239";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrls920_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrls920_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrls920_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrls920_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463921"]),
        None,
        Some("."),
        Some("JODF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLWC3626 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463926.JOCA01000001_gene4258";
/// let this_library_node_name2 = "1463926.JOCA01000093_gene907";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlwc3626_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlwc3626_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlwc3626_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlwc3626_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463926"]),
        None,
        Some("."),
        Some("JOCA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLWC3742 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463934.JOCF01000001_gene6781";
/// let this_library_node_name2 = "1463934.JOCF01000231_gene6250";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlwc3742_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlwc3742_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlwc3742_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlwc3742_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463934"]),
        None,
        Some("."),
        Some("JOCF01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLWC3773 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1463936.JOJI01000001_gene1742";
/// let this_library_node_name2 = "1463936.JOJI01000280_gene500";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlwc3773_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlwc3773_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlwc3773_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlwc3773_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1463936"]),
        None,
        Some("."),
        Some("JOJI01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Micromonospora parva nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1464048.JNZS01000001_gene10";
/// let this_library_node_name2 = "1464048.JNZS01000087_gene2005";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_micromonospora_parva_node_name(this_library_node_name1));
/// assert!(is_valid_string_micromonospora_parva_node_name(this_library_node_name2));
/// assert!(!is_valid_string_micromonospora_parva_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_micromonospora_parva_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1464048"]),
        None,
        Some("."),
        Some("JNZS010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thioalkalivibrio sp. HK1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1469245.JFBG01000001_gene482";
/// let this_library_node_name2 = "1469245.JFBG01000114_gene551";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thioalkalivibrio_sp_hk1_node_name(this_library_node_name1));
/// assert!(is_valid_string_thioalkalivibrio_sp_hk1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thioalkalivibrio_sp_hk1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thioalkalivibrio_sp_hk1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1469245"]),
        None,
        Some("."),
        Some("JFBG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lacinutrix sp. PAMC27137 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1469557.JSWF01000001_gene827";
/// let this_library_node_name2 = "1469557.JSWF01000046_gene224";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lacinutrix_sp_pamc27137_node_name(this_library_node_name1));
/// assert!(is_valid_string_lacinutrix_sp_pamc27137_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lacinutrix_sp_pamc27137_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lacinutrix_sp_pamc27137_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1469557"]),
        None,
        Some("."),
        Some("JSWF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Scytonema hofmanni nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1469607.KK073764_gene6348";
/// let this_library_node_name2 = "1469607.KK073769_gene6347";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_scytonema_hofmanni_node_name(this_library_node_name1));
/// assert!(is_valid_string_scytonema_hofmanni_node_name(this_library_node_name2));
/// assert!(!is_valid_string_scytonema_hofmanni_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_scytonema_hofmanni_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1469607"]),
        None,
        Some("."),
        Some("KK07376"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhodovulum sp. NI22 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1469613.JT55_00005";
/// let this_library_node_name2 = "1469613.JT55_19480";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhodovulum_sp_ni22_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhodovulum_sp_ni22_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhodovulum_sp_ni22_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhodovulum_sp_ni22_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1469613"]),
        None,
        Some("."),
        Some("JT55_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. KNHs209 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1469948.JPNB01000001_gene1000";
/// let this_library_node_name2 = "1469948.JPNB01000003_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_knhs209_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_knhs209_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_knhs209_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_knhs209_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1469948"]),
        None,
        Some("."),
        Some("JPNB0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. RIT328 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1470591.BW41_00001";
/// let this_library_node_name2 = "1470591.BW41_04062";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_rit328_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_rit328_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_rit328_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_rit328_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1470591"]),
        None,
        Some("."),
        Some("BW41_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. RIT357 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1470593.BW43_00001";
/// let this_library_node_name2 = "1470593.BW43_05620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_rit357_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_rit357_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_rit357_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_rit357_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1470593"]),
        None,
        Some("."),
        Some("BW43_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus sp. scB241528O2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1471459.JFLJ01000001_gene1642";
/// let this_library_node_name2 = "1471459.JFLJ01000232_gene1569";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_sp_scb241528o2_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_sp_scb241528o2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_sp_scb241528o2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_sp_scb241528o2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1471459"]),
        None,
        Some("."),
        Some("JFLJ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus sp. scB245a520K10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1471522.JFNU01000001_gene22";
/// let this_library_node_name2 = "1471522.JFNU01000237_gene36";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_sp_scb245a520k10_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_sp_scb245a520k10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_sp_scb245a520k10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_sp_scb245a520k10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1471522"]),
        None,
        Some("."),
        Some("JFNU01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Falsirhodobacter sp. alg1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1472418.BBJC01000001_gene1";
/// let this_library_node_name2 = "1472418.BBJC01000205_gene3079";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_falsirhodobacter_sp_alg1_node_name(this_library_node_name1));
/// assert!(is_valid_string_falsirhodobacter_sp_alg1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_falsirhodobacter_sp_alg1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_falsirhodobacter_sp_alg1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1472418"]),
        None,
        Some("."),
        Some("BBJC01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sp. K24 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1472716.KBK24_0100005";
/// let this_library_node_name2 = "1472716.KBK24_0138325";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sp_k24_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sp_k24_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sp_k24_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sp_k24_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1472716"]),
        None,
        Some("."),
        Some("KBK24_01"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lysinibacillus sp. BF4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1473546.CH76_00010";
/// let this_library_node_name2 = "1473546.CH76_13695";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lysinibacillus_sp_bf4_node_name(this_library_node_name1));
/// assert!(is_valid_string_lysinibacillus_sp_bf4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lysinibacillus_sp_bf4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lysinibacillus_sp_bf4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1473546"]),
        None,
        Some("."),
        Some("CH76_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus phoenicis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1476583.DEIPH_ctg001orf0001";
/// let this_library_node_name2 = "1476583.DEIPH_ctg145orf0002";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_phoenicis_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_phoenicis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_phoenicis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_phoenicis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1476583"]),
        None,
        Some("."),
        Some("DEIPH_ctg"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Streptomyces sp. NRRLB24720 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1476876.JOJO01000001_gene7307";
/// let this_library_node_name2 = "1476876.JOJO01000171_gene818";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_streptomyces_sp_nrrlb24720_node_name(this_library_node_name1));
/// assert!(is_valid_string_streptomyces_sp_nrrlb24720_node_name(this_library_node_name2));
/// assert!(!is_valid_string_streptomyces_sp_nrrlb24720_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_streptomyces_sp_nrrlb24720_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1476876"]),
        None,
        Some("."),
        Some("JOJO01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Peptostreptococcaceae bacterium VA2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1476973.JMMB01000001_gene3337";
/// let this_library_node_name2 = "1476973.JMMB01000011_gene86";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_peptostreptococcaceae_bacterium_va2_node_name(this_library_node_name1));
/// assert!(is_valid_string_peptostreptococcaceae_bacterium_va2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_peptostreptococcaceae_bacterium_va2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_peptostreptococcaceae_bacterium_va2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1476973"]),
        None,
        Some("."),
        Some("JMMB010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas sp. HL48 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1479235.KK366039_gene1";
/// let this_library_node_name2 = "1479235.KK366039_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_sp_hl48_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_sp_hl48_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_sp_hl48_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_sp_hl48_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1479235"]),
        None,
        Some("."),
        Some("KK366039_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Marinobacter sp. HL58 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1479237.JMLY01000001_gene1";
/// let this_library_node_name2 = "1479237.JMLY01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_marinobacter_sp_hl58_node_name(this_library_node_name1));
/// assert!(is_valid_string_marinobacter_sp_hl58_node_name(this_library_node_name2));
/// assert!(!is_valid_string_marinobacter_sp_hl58_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_marinobacter_sp_hl58_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1479237"]),
        None,
        Some("."),
        Some("JMLY01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oceanicaulis sp. HL87 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1479238.JQMZ01000001_gene1";
/// let this_library_node_name2 = "1479238.JQMZ01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oceanicaulis_sp_hl87_node_name(this_library_node_name1));
/// assert!(is_valid_string_oceanicaulis_sp_hl87_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oceanicaulis_sp_hl87_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oceanicaulis_sp_hl87_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1479238"]),
        None,
        Some("."),
        Some("JQMZ01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyrobacter sp. HL46 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1479239.JQMU01000001_gene1000";
/// let this_library_node_name2 = "1479239.JQMU01000002_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyrobacter_sp_hl46_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyrobacter_sp_hl46_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyrobacter_sp_hl46_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyrobacter_sp_hl46_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1479239"]),
        None,
        Some("."),
        Some("JQMU0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Curtobacterium sp. S6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1479623.JHEL01000004_gene2277";
/// let this_library_node_name2 = "1479623.JHEL01000015_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_curtobacterium_sp_s6_node_name(this_library_node_name1));
/// assert!(is_valid_string_curtobacterium_sp_s6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_curtobacterium_sp_s6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_curtobacterium_sp_s6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1479623"]),
        None,
        Some("."),
        Some("JHEL010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Spirochaeta sp. JC230 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1480694.DC28_00005";
/// let this_library_node_name2 = "1480694.DC28_15440";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_spirochaeta_sp_jc230_node_name(this_library_node_name1));
/// assert!(is_valid_string_spirochaeta_sp_jc230_node_name(this_library_node_name2));
/// assert!(!is_valid_string_spirochaeta_sp_jc230_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_spirochaeta_sp_jc230_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1480694"]),
        None,
        Some("."),
        Some("DC28_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea sp. PSNIH2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1484157.PSNIH2_00005";
/// let this_library_node_name2 = "1484157.PSNIH2_23405";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_sp_psnih2_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_sp_psnih2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_sp_psnih2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_sp_psnih2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1484157"]),
        None,
        Some("."),
        Some("PSNIH2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pantoea sp. PSNIH1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1484158.PSNIH1_00010";
/// let this_library_node_name2 = "1484158.PSNIH1_21045";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pantoea_sp_psnih1_node_name(this_library_node_name1));
/// assert!(is_valid_string_pantoea_sp_psnih1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pantoea_sp_psnih1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pantoea_sp_psnih1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1484158"]),
        None,
        Some("."),
        Some("PSNIH1_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Psychroserpens sp. PAMC27130 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1484460.JSWG01000001_gene2084";
/// let this_library_node_name2 = "1484460.JSWG01000060_gene821";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_psychroserpens_sp_pamc27130_node_name(this_library_node_name1));
/// assert!(is_valid_string_psychroserpens_sp_pamc27130_node_name(this_library_node_name2));
/// assert!(!is_valid_string_psychroserpens_sp_pamc27130_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_psychroserpens_sp_pamc27130_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1484460"]),
        None,
        Some("."),
        Some("JSWG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Exiguobacterium sp. AB2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1484479.DI14_00010";
/// let this_library_node_name2 = "1484479.DI14_15310";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_exiguobacterium_sp_ab2_node_name(this_library_node_name1));
/// assert!(is_valid_string_exiguobacterium_sp_ab2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_exiguobacterium_sp_ab2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_exiguobacterium_sp_ab2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1484479"]),
        None,
        Some("."),
        Some("DI14_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Selenomonas sp. AE3005 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1485543.JMME01000001_gene1058";
/// let this_library_node_name2 = "1485543.JMME01000028_gene2469";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_selenomonas_sp_ae3005_node_name(this_library_node_name1));
/// assert!(is_valid_string_selenomonas_sp_ae3005_node_name(this_library_node_name2));
/// assert!(!is_valid_string_selenomonas_sp_ae3005_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_selenomonas_sp_ae3005_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1485543"]),
        None,
        Some("."),
        Some("JMME010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ferriphaselus sp. R1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1485544.JQKP01000001_gene1000";
/// let this_library_node_name2 = "1485544.JQKP01000025_gene860";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ferriphaselus_sp_r1_node_name(this_library_node_name1));
/// assert!(is_valid_string_ferriphaselus_sp_r1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ferriphaselus_sp_r1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ferriphaselus_sp_r1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1485544"]),
        None,
        Some("."),
        Some("JQKP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Zetaproteobacteria bacterium TAG1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1485545.JQLW01000001_gene1398";
/// let this_library_node_name2 = "1485545.JQLW01000013_gene1855";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_zetaproteobacteria_bacterium_tag1_node_name(this_library_node_name1));
/// assert!(is_valid_string_zetaproteobacteria_bacterium_tag1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_zetaproteobacteria_bacterium_tag1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_zetaproteobacteria_bacterium_tag1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1485545"]),
        None,
        Some("."),
        Some("JQLW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. HMP27 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1487921.DP68_00005";
/// let this_library_node_name2 = "1487921.DP68_18760";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_hmp27_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_hmp27_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_hmp27_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_hmp27_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1487921"]),
        None,
        Some("."),
        Some("DP68_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Desulfosporosinus sp. HMP52 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1487923.DP73_00005";
/// let this_library_node_name2 = "1487923.DP73_21885";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_desulfosporosinus_sp_hmp52_node_name(this_library_node_name1));
/// assert!(is_valid_string_desulfosporosinus_sp_hmp52_node_name(this_library_node_name2));
/// assert!(!is_valid_string_desulfosporosinus_sp_hmp52_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_desulfosporosinus_sp_hmp52_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1487923"]),
        None,
        Some("."),
        Some("DP73_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Leptolyngbya sp. JSC1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1487953.JMKF01000001_gene481";
/// let this_library_node_name2 = "1487953.JMKF01000095_gene5216";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_leptolyngbya_sp_jsc1_node_name(this_library_node_name1));
/// assert!(is_valid_string_leptolyngbya_sp_jsc1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_leptolyngbya_sp_jsc1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_leptolyngbya_sp_jsc1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1487953"]),
        None,
        Some("."),
        Some("JMKF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Corynebacterium sp. ATCC6931 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1487956.DR71_1";
/// let this_library_node_name2 = "1487956.DR71_999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_corynebacterium_sp_atcc6931_node_name(this_library_node_name1));
/// assert!(is_valid_string_corynebacterium_sp_atcc6931_node_name(this_library_node_name2));
/// assert!(!is_valid_string_corynebacterium_sp_atcc6931_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_corynebacterium_sp_atcc6931_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1487956"]),
        None,
        Some("."),
        Some("DR71_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. Ant303 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1488328.JMCL01000001_gene2926";
/// let this_library_node_name2 = "1488328.JMCL01000266_gene2472";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_ant303_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_ant303_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_ant303_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_ant303_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1488328"]),
        None,
        Some("."),
        Some("JMCL01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus sp. RL nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1489678.RDMS_00005";
/// let this_library_node_name2 = "1489678.RDMS_13850";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_sp_rl_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_sp_rl_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_sp_rl_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_sp_rl_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1489678"]),
        None,
        Some("."),
        Some("RDMS_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium sp. EM1308 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1492737.FEM08_00010";
/// let this_library_node_name2 = "1492737.FEM08_36610";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_sp_em1308_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_sp_em1308_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_sp_em1308_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_sp_em1308_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1492737"]),
        None,
        Some("."),
        Some("FEM08_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium sp. EM1321 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1492738.FEM21_00010";
/// let this_library_node_name2 = "1492738.FEM21_32300";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_sp_em1321_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_sp_em1321_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_sp_em1321_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_sp_em1321_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1492738"]),
        None,
        Some("."),
        Some("FEM21_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Gammaproteobacteria bacterium MFB021 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1492922.GY26_00010";
/// let this_library_node_name2 = "1492922.GY26_20510";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_gammaproteobacteria_bacterium_mfb021_node_name(this_library_node_name1));
/// assert!(is_valid_string_gammaproteobacteria_bacterium_mfb021_node_name(this_library_node_name2));
/// assert!(!is_valid_string_gammaproteobacteria_bacterium_mfb021_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_gammaproteobacteria_bacterium_mfb021_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1492922"]),
        None,
        Some("."),
        Some("GY26_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Cyanobium sp. CACIAM14 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1496688.ER33_00005";
/// let this_library_node_name2 = "1496688.ER33_16160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_cyanobium_sp_caciam14_node_name(this_library_node_name1));
/// assert!(is_valid_string_cyanobium_sp_caciam14_node_name(this_library_node_name2));
/// assert!(!is_valid_string_cyanobium_sp_caciam14_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_cyanobium_sp_caciam14_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1496688"]),
        None,
        Some("."),
        Some("ER33_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeriaceae bacterium FSLA50209 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1497679.EP56_00010";
/// let this_library_node_name2 = "1497679.EP56_18160";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeriaceae_bacterium_fsla50209_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeriaceae_bacterium_fsla50209_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeriaceae_bacterium_fsla50209_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeriaceae_bacterium_fsla50209_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1497679"]),
        None,
        Some("."),
        Some("EP56_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus sp. MIT0601 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499498.EV05_0001";
/// let this_library_node_name2 = "1499498.EV05_1983";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_sp_mit0601_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_sp_mit0601_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_sp_mit0601_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_sp_mit0601_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499498"]),
        None,
        Some("."),
        Some("EV05_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus sp. MIT0602 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499499.EV06_0001";
/// let this_library_node_name2 = "1499499.EV06_2057";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_sp_mit0602_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_sp_mit0602_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_sp_mit0602_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_sp_mit0602_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499499"]),
        None,
        Some("."),
        Some("EV06_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus sp. MIT0701 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499502.EV12_0001";
/// let this_library_node_name2 = "1499502.EV12_3126";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_sp_mit0701_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_sp_mit0701_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_sp_mit0701_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_sp_mit0701_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499502"]),
        None,
        Some("."),
        Some("EV12_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. MT2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499680.CCFE01000001_gene1";
/// let this_library_node_name2 = "1499680.CCFE01000033_gene4053";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_mt2_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_mt2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_mt2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_mt2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499680"]),
        None,
        Some("."),
        Some("CCFE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. CL6 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499683.CCFF01000001_gene19";
/// let this_library_node_name2 = "1499683.CCFF01000017_gene3034";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_cl6_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_cl6_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_cl6_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_cl6_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499683"]),
        None,
        Some("."),
        Some("CCFF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. CL2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499684.CCNP01000003_gene1";
/// let this_library_node_name2 = "1499684.CCNP01000026_gene3838";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_cl2_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_cl2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_cl2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_cl2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499684"]),
        None,
        Some("."),
        Some("CCNP010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacillus sp. KW12 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499685.CCFJ01000002_gene2106";
/// let this_library_node_name2 = "1499685.CCFJ01000058_gene1904";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacillus_sp_kw12_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacillus_sp_kw12_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacillus_sp_kw12_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacillus_sp_kw12_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499685"]),
        None,
        Some("."),
        Some("CCFJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. 20BN nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499686.BN1079_00001";
/// let this_library_node_name2 = "1499686.BN1079_03504";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_20bn_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_20bn_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_20bn_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_20bn_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499686"]),
        None,
        Some("."),
        Some("BN1079_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. LF2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499689.CCNN01000001_gene1";
/// let this_library_node_name2 = "1499689.CCNN01000015_gene3483";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_lf2_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_lf2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_lf2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_lf2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499689"]),
        None,
        Some("."),
        Some("CCNN010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacterium UASB270 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499967.BAYZ01000001_gene5904";
/// let this_library_node_name2 = "1499967.BAYZ01000197_gene3065";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacterium_uasb270_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacterium_uasb270_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacterium_uasb270_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacterium_uasb270_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499967"]),
        None,
        Some("."),
        Some("BAYZ01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. TCA20 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1499968.TCA2_0002";
/// let this_library_node_name2 = "1499968.TCA2_6000";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_tca20_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_tca20_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_tca20_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_tca20_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1499968"]),
        None,
        Some("."),
        Some("TCA2_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. YR295 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1500257.JQNM01000001_gene3338";
/// let this_library_node_name2 = "1500257.JQNM01000029_gene3";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_yr295_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_yr295_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_yr295_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_yr295_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1500257"]),
        None,
        Some("."),
        Some("JQNM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. YR519 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1500259.JQLD01000001_gene3418";
/// let this_library_node_name2 = "1500259.JQLD01000029_gene1560";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_yr519_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_yr519_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_yr519_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_yr519_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1500259"]),
        None,
        Some("."),
        Some("JQLD010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chryseobacterium sp. CF284 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1500281.JQKZ01000001_gene1007";
/// let this_library_node_name2 = "1500281.JQKZ01000080_gene2641";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chryseobacterium_sp_cf284_node_name(this_library_node_name1));
/// assert!(is_valid_string_chryseobacterium_sp_cf284_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chryseobacterium_sp_cf284_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chryseobacterium_sp_cf284_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1500281"]),
        None,
        Some("."),
        Some("JQKZ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. CF097 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1500301.JQMF01000001_gene10";
/// let this_library_node_name2 = "1500301.JQMF01000059_gene1950";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_cf097_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_cf097_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_cf097_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_cf097_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1500301"]),
        None,
        Some("."),
        Some("JQMF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. CF394 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1500304.JQKY01000001_gene4806";
/// let this_library_node_name2 = "1500304.JQKY01000052_gene2186";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_cf394_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_cf394_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_cf394_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_cf394_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1500304"]),
        None,
        Some("."),
        Some("JQKY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. OK494 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1500306.JQLA01000001_gene2835";
/// let this_library_node_name2 = "1500306.JQLA01000079_gene3481";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_ok494_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_ok494_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_ok494_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_ok494_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1500306"]),
        None,
        Some("."),
        Some("JQLA010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Luteibacter sp. 9143 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1500890.JQNL01000001_gene1";
/// let this_library_node_name2 = "1500890.JQNL01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_luteibacter_sp_9143_node_name(this_library_node_name1));
/// assert!(is_valid_string_luteibacter_sp_9143_node_name(this_library_node_name2));
/// assert!(!is_valid_string_luteibacter_sp_9143_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_luteibacter_sp_9143_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1500890"]),
        None,
        Some("."),
        Some("JQNL01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Luteibacter sp. 9135 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1500893.JQNB01000001_gene1";
/// let this_library_node_name2 = "1500893.JQNB01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_luteibacter_sp_9135_node_name(this_library_node_name1));
/// assert!(is_valid_string_luteibacter_sp_9135_node_name(this_library_node_name2));
/// assert!(!is_valid_string_luteibacter_sp_9135_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_luteibacter_sp_9135_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1500893"]),
        None,
        Some("."),
        Some("JQNB01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Massilia sp. 9096 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1500894.JQNN01000001_gene1";
/// let this_library_node_name2 = "1500894.JQNN01000002_gene4640";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_massilia_sp_9096_node_name(this_library_node_name1));
/// assert!(is_valid_string_massilia_sp_9096_node_name(this_library_node_name2));
/// assert!(!is_valid_string_massilia_sp_9096_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_massilia_sp_9096_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1500894"]),
        None,
        Some("."),
        Some("JQNN0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderia sp. 9120 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1500897.JQNA01000001_gene5381";
/// let this_library_node_name2 = "1500897.JQNA01000002_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderia_sp_9120_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderia_sp_9120_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderia_sp_9120_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderia_sp_9120_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1500897"]),
        None,
        Some("."),
        Some("JQNA0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. MSt1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1501230.ET33_00015";
/// let this_library_node_name2 = "1501230.ET33_37740";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_mst1_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_mst1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_mst1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_mst1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1501230"]),
        None,
        Some("."),
        Some("ET33_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus sp. MIT0604 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1501268.EW14_0001";
/// let this_library_node_name2 = "1501268.EW14_2085";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_sp_mit0604_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_sp_mit0604_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_sp_mit0604_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_sp_mit0604_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1501268"]),
        None,
        Some("."),
        Some("EW14_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Prochlorococcus sp. MIT0801 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1501269.EW15_0001";
/// let this_library_node_name2 = "1501269.EW15_2287";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_prochlorococcus_sp_mit0801_node_name(this_library_node_name1));
/// assert!(is_valid_string_prochlorococcus_sp_mit0801_node_name(this_library_node_name2));
/// assert!(!is_valid_string_prochlorococcus_sp_mit0801_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_prochlorococcus_sp_mit0801_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1501269"]),
        None,
        Some("."),
        Some("EW15_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alistipes sp. 627 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1501391.LG35_00005";
/// let this_library_node_name2 = "1501391.LG35_10465";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alistipes_sp_627_node_name(this_library_node_name1));
/// assert!(is_valid_string_alistipes_sp_627_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alistipes_sp_627_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alistipes_sp_627_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1501391"]),
        None,
        Some("."),
        Some("LG35_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Devosia sp. LC5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1502724.FF80_00001";
/// let this_library_node_name2 = "1502724.FF80_04172";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_devosia_sp_lc5_node_name(this_library_node_name1));
/// assert!(is_valid_string_devosia_sp_lc5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_devosia_sp_lc5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_devosia_sp_lc5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1502724"]),
        None,
        Some("."),
        Some("FF80_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Methylotenera sp. L2L1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1502770.JQMG01000001_gene1";
/// let this_library_node_name2 = "1502770.JQMG01000001_gene999";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_methylotenera_sp_l2l1_node_name(this_library_node_name1));
/// assert!(is_valid_string_methylotenera_sp_l2l1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_methylotenera_sp_l2l1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_methylotenera_sp_l2l1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1502770"]),
        None,
        Some("."),
        Some("JQMG01000001_gene"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingopyxis sp. LC81 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1502850.FG91_00001";
/// let this_library_node_name2 = "1502850.FG91_04159";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingopyxis_sp_lc81_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingopyxis_sp_lc81_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingopyxis_sp_lc81_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingopyxis_sp_lc81_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1502850"]),
        None,
        Some("."),
        Some("FG91_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bosea sp. LC85 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1502851.FG93_00001";
/// let this_library_node_name2 = "1502851.FG93_06246";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bosea_sp_lc85_node_name(this_library_node_name1));
/// assert!(is_valid_string_bosea_sp_lc85_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bosea_sp_lc85_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bosea_sp_lc85_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1502851"]),
        None,
        Some("."),
        Some("FG93_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Massilia sp. LC238 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1502852.FG94_00001";
/// let this_library_node_name2 = "1502852.FG94_05184";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_massilia_sp_lc238_node_name(this_library_node_name1));
/// assert!(is_valid_string_massilia_sp_lc238_node_name(this_library_node_name2));
/// assert!(!is_valid_string_massilia_sp_lc238_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_massilia_sp_lc238_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1502852"]),
        None,
        Some("."),
        Some("FG94_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING actinobacterium acAMD5 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1504319.GM45_0005";
/// let this_library_node_name2 = "1504319.GM45_6295";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_actinobacterium_acamd5_node_name(this_library_node_name1));
/// assert!(is_valid_string_actinobacterium_acamd5_node_name(this_library_node_name2));
/// assert!(!is_valid_string_actinobacterium_acamd5_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_actinobacterium_acamd5_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1504319"]),
        None,
        Some("."),
        Some("GM45_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Polaromonas sp. CG912 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1504672.669782728";
/// let this_library_node_name2 = "1504672.669787708";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_polaromonas_sp_cg912_node_name(this_library_node_name1));
/// assert!(is_valid_string_polaromonas_sp_cg912_node_name(this_library_node_name2));
/// assert!(!is_valid_string_polaromonas_sp_cg912_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_polaromonas_sp_cg912_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1504672"]),
        None,
        Some("."),
        Some("66978"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacterium sp. OL1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1504822.CCNO01000001_gene1670";
/// let this_library_node_name2 = "1504822.CCNO01000016_gene280";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacterium_sp_ol1_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacterium_sp_ol1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacterium_sp_ol1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacterium_sp_ol1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1504822"]),
        None,
        Some("."),
        Some("CCNO010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bacterium sp. LF3 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1504823.CCMM01000001_gene1";
/// let this_library_node_name2 = "1504823.CCMM01000013_gene2873";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bacterium_sp_lf3_node_name(this_library_node_name1));
/// assert!(is_valid_string_bacterium_sp_lf3_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bacterium_sp_lf3_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bacterium_sp_lf3_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1504823"]),
        None,
        Some("."),
        Some("CCMM010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Halomonas sp. KO116 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1504981.KO116_0001";
/// let this_library_node_name2 = "1504981.KO116_4842";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_halomonas_sp_ko116_node_name(this_library_node_name1));
/// assert!(is_valid_string_halomonas_sp_ko116_node_name(this_library_node_name2));
/// assert!(!is_valid_string_halomonas_sp_ko116_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_halomonas_sp_ko116_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1504981"]),
        None,
        Some("."),
        Some("KO116_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Flavobacterium sp. Fl nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1506583.JQJY01000001_gene100";
/// let this_library_node_name2 = "1506583.JQJY01000022_gene3777";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_flavobacterium_sp_fl_node_name(this_library_node_name1));
/// assert!(is_valid_string_flavobacterium_sp_fl_node_name(this_library_node_name2));
/// assert!(!is_valid_string_flavobacterium_sp_fl_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_flavobacterium_sp_fl_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1506583"]),
        None,
        Some("."),
        Some("JQJY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Butyrivibrio sp. AE3004 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1506994.JNLQ01000001_gene1";
/// let this_library_node_name2 = "1506994.JNLQ01000006_gene437";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_butyrivibrio_sp_ae3004_node_name(this_library_node_name1));
/// assert!(is_valid_string_butyrivibrio_sp_ae3004_node_name(this_library_node_name2));
/// assert!(!is_valid_string_butyrivibrio_sp_ae3004_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_butyrivibrio_sp_ae3004_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1506994"]),
        None,
        Some("."),
        Some("JNLQ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Arthromitus sp. SFBmouseNL nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1508644.SFBmNL_00001";
/// let this_library_node_name2 = "1508644.SFBmNL_01651";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_arthromitus_sp_sfbmousenl_node_name(this_library_node_name1));
/// assert!(is_valid_string_arthromitus_sp_sfbmousenl_node_name(this_library_node_name2));
/// assert!(!is_valid_string_arthromitus_sp_sfbmousenl_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_arthromitus_sp_sfbmousenl_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1508644"]),
        None,
        Some("."),
        Some("SFBmNL_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Acinetobacter sp. HR7 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1509403.GW12_00010";
/// let this_library_node_name2 = "1509403.GW12_29350";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_acinetobacter_sp_hr7_node_name(this_library_node_name1));
/// assert!(is_valid_string_acinetobacter_sp_hr7_node_name(this_library_node_name2));
/// assert!(!is_valid_string_acinetobacter_sp_hr7_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_acinetobacter_sp_hr7_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1509403"]),
        None,
        Some("."),
        Some("GW12_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. R1200B2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1509405.GV67_00010";
/// let this_library_node_name2 = "1509405.GV67_25620";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_r1200b2_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_r1200b2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_r1200b2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_r1200b2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1509405"]),
        None,
        Some("."),
        Some("GV67_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Bosea sp. UNC402CLCol nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1510531.JQJJ01000001_gene4410";
/// let this_library_node_name2 = "1510531.JQJJ01000017_gene4409";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_bosea_sp_unc402clcol_node_name(this_library_node_name1));
/// assert!(is_valid_string_bosea_sp_unc402clcol_node_name(this_library_node_name2));
/// assert!(!is_valid_string_bosea_sp_unc402clcol_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_bosea_sp_unc402clcol_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1510531"]),
        None,
        Some("."),
        Some("JQJJ010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Ruminococcus sp. HUN007 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1514668.JOOA01000001_gene100";
/// let this_library_node_name2 = "1514668.JOOA01000004_gene3529";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_ruminococcus_sp_hun007_node_name(this_library_node_name1));
/// assert!(is_valid_string_ruminococcus_sp_hun007_node_name(this_library_node_name2));
/// assert!(!is_valid_string_ruminococcus_sp_hun007_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_ruminococcus_sp_hun007_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1514668"]),
        None,
        Some("."),
        Some("JOOA0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas sp. COT239OH1446 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1515613.HQ37_00010";
/// let this_library_node_name2 = "1515613.HQ37_08395";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_sp_cot239oh1446_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_sp_cot239oh1446_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_sp_cot239oh1446_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_sp_cot239oh1446_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1515613"]),
        None,
        Some("."),
        Some("HQ37_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonas sp. COT290OH860 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1515615.HQ41_00010";
/// let this_library_node_name2 = "1515615.HQ41_09635";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonas_sp_cot290oh860_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonas_sp_cot290oh860_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonas_sp_cot290oh860_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonas_sp_cot290oh860_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1515615"]),
        None,
        Some("."),
        Some("HQ41_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella sp. YQH10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1515746.HR45_00005";
/// let this_library_node_name2 = "1515746.HR45_19415";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_sp_yqh10_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_sp_yqh10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_sp_yqh10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_sp_yqh10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1515746"]),
        None,
        Some("."),
        Some("HR45_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Idiomarina sp. MCCC1A10513 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1517416.IDAT_00010";
/// let this_library_node_name2 = "1517416.IDAT_13060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_idiomarina_sp_mccc1a10513_node_name(this_library_node_name1));
/// assert!(is_valid_string_idiomarina_sp_mccc1a10513_node_name(this_library_node_name2));
/// assert!(!is_valid_string_idiomarina_sp_mccc1a10513_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_idiomarina_sp_mccc1a10513_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1517416"]),
        None,
        Some("."),
        Some("IDAT_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Vibrio sp. ER1A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1517681.HW45_00015";
/// let this_library_node_name2 = "1517681.HW45_29015";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_vibrio_sp_er1a_node_name(this_library_node_name1));
/// assert!(is_valid_string_vibrio_sp_er1a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_vibrio_sp_er1a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_vibrio_sp_er1a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1517681"]),
        None,
        Some("."),
        Some("HW45_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Porphyromonadaceae COT184OH4590 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1517682.HW49_00010";
/// let this_library_node_name2 = "1517682.HW49_11385";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_porphyromonadaceae_cot184oh4590_node_name(this_library_node_name1));
/// assert!(is_valid_string_porphyromonadaceae_cot184oh4590_node_name(this_library_node_name2));
/// assert!(!is_valid_string_porphyromonadaceae_cot184oh4590_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_porphyromonadaceae_cot184oh4590_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1517682"]),
        None,
        Some("."),
        Some("HW49_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Oscillibacter sp. ER4 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1519439.JPJG01000001_gene1277";
/// let this_library_node_name2 = "1519439.JPJG01000130_gene885";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_oscillibacter_sp_er4_node_name(this_library_node_name1));
/// assert!(is_valid_string_oscillibacter_sp_er4_node_name(this_library_node_name2));
/// assert!(!is_valid_string_oscillibacter_sp_er4_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_oscillibacter_sp_er4_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1519439"]),
        None,
        Some("."),
        Some("JPJG01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chlorobium sp. GBChlB nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1519464.HY22_00015";
/// let this_library_node_name2 = "1519464.HY22_14520";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chlorobium_sp_gbchlb_node_name(this_library_node_name1));
/// assert!(is_valid_string_chlorobium_sp_gbchlb_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chlorobium_sp_gbchlb_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chlorobium_sp_gbchlb_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1519464"]),
        None,
        Some("."),
        Some("HY22_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Chloroflexus sp. MSG nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1521187.JPIM01000001_gene834";
/// let this_library_node_name2 = "1521187.JPIM01000251_gene1695";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_chloroflexus_sp_msg_node_name(this_library_node_name1));
/// assert!(is_valid_string_chloroflexus_sp_msg_node_name(this_library_node_name2));
/// assert!(!is_valid_string_chloroflexus_sp_msg_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_chloroflexus_sp_msg_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1521187"]),
        None,
        Some("."),
        Some("JPIM01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobium sp. ba1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1522072.IL54_0001";
/// let this_library_node_name2 = "1522072.IL54_4592";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobium_sp_ba1_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobium_sp_ba1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobium_sp_ba1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobium_sp_ba1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1522072"]),
        None,
        Some("."),
        Some("IL54_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Pseudomonas sp. ML96 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1523503.JPMY01000001_gene3690";
/// let this_library_node_name2 = "1523503.JPMY01000047_gene1063";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_pseudomonas_sp_ml96_node_name(this_library_node_name1));
/// assert!(is_valid_string_pseudomonas_sp_ml96_node_name(this_library_node_name2));
/// assert!(!is_valid_string_pseudomonas_sp_ml96_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_pseudomonas_sp_ml96_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1523503"]),
        None,
        Some("."),
        Some("JPMY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Serratia sp. Ag1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1524467.IV04_00005";
/// let this_library_node_name2 = "1524467.IV04_25265";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_serratia_sp_ag1_node_name(this_library_node_name1));
/// assert!(is_valid_string_serratia_sp_ag1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_serratia_sp_ag1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_serratia_sp_ag1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1524467"]),
        None,
        Some("."),
        Some("IV04_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus sp. 4681 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1525715.IX54_00005";
/// let this_library_node_name2 = "1525715.IX54_16695";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_sp_4681_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_sp_4681_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_sp_4681_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_sp_4681_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1525715"]),
        None,
        Some("."),
        Some("IX54_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Planococcus sp. PAMC21323 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1526927.Plano_0001";
/// let this_library_node_name2 = "1526927.Plano_p0002";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_planococcus_sp_pamc21323_node_name(this_library_node_name1));
/// assert!(is_valid_string_planococcus_sp_pamc21323_node_name(this_library_node_name2));
/// assert!(!is_valid_string_planococcus_sp_pamc21323_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_planococcus_sp_pamc21323_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1526927"]),
        None,
        Some("."),
        Some("Plano_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Atelocyanobacterium thalassa SIO64986 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1527444.ucyna2_00001";
/// let this_library_node_name2 = "1527444.ucyna2_01297";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_atelocyanobacterium_thalassa_sio64986_node_name(this_library_node_name1));
/// assert!(is_valid_string_atelocyanobacterium_thalassa_sio64986_node_name(this_library_node_name2));
/// assert!(!is_valid_string_atelocyanobacterium_thalassa_sio64986_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_atelocyanobacterium_thalassa_sio64986_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1527444"]),
        None,
        Some("."),
        Some("ucyna2_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rickettsiales bacterium Ac37b nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1528098.NOVO_00005";
/// let this_library_node_name2 = "1528098.NOVO_09460";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rickettsiales_bacterium_ac37b_node_name(this_library_node_name1));
/// assert!(is_valid_string_rickettsiales_bacterium_ac37b_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rickettsiales_bacterium_ac37b_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rickettsiales_bacterium_ac37b_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1528098"]),
        None,
        Some("."),
        Some("NOVO_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thalassospira australica nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1528106.JRJE01000001_gene2031";
/// let this_library_node_name2 = "1528106.JRJE01000032_gene3206";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thalassospira_australica_node_name(this_library_node_name1));
/// assert!(is_valid_string_thalassospira_australica_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thalassospira_australica_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thalassospira_australica_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1528106"]),
        None,
        Some("."),
        Some("JRJE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Maribius sp. MOLA401 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1530186.JQEY01000001_gene1000";
/// let this_library_node_name2 = "1530186.JQEY01000033_gene1844";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_maribius_sp_mola401_node_name(this_library_node_name1));
/// assert!(is_valid_string_maribius_sp_mola401_node_name(this_library_node_name2));
/// assert!(!is_valid_string_maribius_sp_mola401_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_maribius_sp_mola401_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1530186"]),
        None,
        Some("."),
        Some("JQEY010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Achromobacter sp. RTa nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1532557.JL37_00005";
/// let this_library_node_name2 = "1532557.JL37_29960";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_achromobacter_sp_rta_node_name(this_library_node_name1));
/// assert!(is_valid_string_achromobacter_sp_rta_node_name(this_library_node_name2));
/// assert!(!is_valid_string_achromobacter_sp_rta_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_achromobacter_sp_rta_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1532557"]),
        None,
        Some("."),
        Some("JL37_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Rhizobium sp. YS1r nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1532558.JL39_00005";
/// let this_library_node_name2 = "1532558.JL39_31450";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_rhizobium_sp_ys1r_node_name(this_library_node_name1));
/// assert!(is_valid_string_rhizobium_sp_ys1r_node_name(this_library_node_name2));
/// assert!(!is_valid_string_rhizobium_sp_ys1r_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_rhizobium_sp_ys1r_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1532558"]),
        None,
        Some("."),
        Some("JL39_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Devosia sp. 172E8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1535287.JP74_00005";
/// let this_library_node_name2 = "1535287.JP74_23535";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_devosia_sp_172e8_node_name(this_library_node_name1));
/// assert!(is_valid_string_devosia_sp_172e8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_devosia_sp_172e8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_devosia_sp_172e8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1535287"]),
        None,
        Some("."),
        Some("JP74_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Thalassotalea sp. ND16A nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1535422.ND16A_0001";
/// let this_library_node_name2 = "1535422.ND16A_3956";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_thalassotalea_sp_nd16a_node_name(this_library_node_name1));
/// assert!(is_valid_string_thalassotalea_sp_nd16a_node_name(this_library_node_name2));
/// assert!(!is_valid_string_thalassotalea_sp_nd16a_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_thalassotalea_sp_nd16a_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1535422"]),
        None,
        Some("."),
        Some("ND16A_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. FSLP40081 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1536769.P40081_00010";
/// let this_library_node_name2 = "1536769.P40081_37515";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_fslp40081_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_fslp40081_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_fslp40081_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_fslp40081_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1536769"]),
        None,
        Some("."),
        Some("P40081_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. FSLR50345 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1536770.R50345_00010";
/// let this_library_node_name2 = "1536770.R50345_30815";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_fslr50345_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_fslr50345_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_fslr50345_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_fslr50345_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1536770"]),
        None,
        Some("."),
        Some("R50345_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. FSLR70273 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1536772.R70723_00005";
/// let this_library_node_name2 = "1536772.R70723_32545";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_fslr70273_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_fslr70273_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_fslr70273_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_fslr70273_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1536772"]),
        None,
        Some("."),
        Some("R70723_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. FSLR70331 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1536773.R70331_00010";
/// let this_library_node_name2 = "1536773.R70331_31325";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_fslr70331_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_fslr70331_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_fslr70331_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_fslr70331_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1536773"]),
        None,
        Some("."),
        Some("R70331_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. FSLH70357 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1536774.H70357_00005";
/// let this_library_node_name2 = "1536774.H70357_35360";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_fslh70357_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_fslh70357_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_fslh70357_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_fslh70357_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1536774"]),
        None,
        Some("."),
        Some("H70357_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paenibacillus sp. FSLH70737 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1536775.H70737_00010";
/// let this_library_node_name2 = "1536775.H70737_30350";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paenibacillus_sp_fslh70737_node_name(this_library_node_name1));
/// assert!(is_valid_string_paenibacillus_sp_fslh70737_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paenibacillus_sp_fslh70737_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paenibacillus_sp_fslh70737_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1536775"]),
        None,
        Some("."),
        Some("H70737_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingopyxis sp. MWB1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1537715.JQFJ01000001_gene2634";
/// let this_library_node_name2 = "1537715.JQFJ01000005_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingopyxis_sp_mwb1_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingopyxis_sp_mwb1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingopyxis_sp_mwb1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingopyxis_sp_mwb1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1537715"]),
        None,
        Some("."),
        Some("JQFJ0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurospirillum sp. SCADC nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1537915.JU57_00010";
/// let this_library_node_name2 = "1537915.JU57_13890";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurospirillum_sp_scadc_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurospirillum_sp_scadc_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurospirillum_sp_scadc_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurospirillum_sp_scadc_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1537915"]),
        None,
        Some("."),
        Some("JU57_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfuricurvum sp. MLSB nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1537917.JU82_00010";
/// let this_library_node_name2 = "1537917.JU82_11895";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfuricurvum_sp_mlsb_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfuricurvum_sp_mlsb_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfuricurvum_sp_mlsb_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfuricurvum_sp_mlsb_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1537917"]),
        None,
        Some("."),
        Some("JU82_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Alteromonas sp. LOR nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1537994.JQFW01000001_gene3496";
/// let this_library_node_name2 = "1537994.JQFW01000057_gene622";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_alteromonas_sp_lor_node_name(this_library_node_name1));
/// assert!(is_valid_string_alteromonas_sp_lor_node_name(this_library_node_name2));
/// assert!(!is_valid_string_alteromonas_sp_lor_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_alteromonas_sp_lor_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1537994"]),
        None,
        Some("."),
        Some("JQFW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Aquabacterium sp. NJ1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1538295.JY96_00005";
/// let this_library_node_name2 = "1538295.JY96_21810";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_aquabacterium_sp_nj1_node_name(this_library_node_name1));
/// assert!(is_valid_string_aquabacterium_sp_nj1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_aquabacterium_sp_nj1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_aquabacterium_sp_nj1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1538295"]),
        None,
        Some("."),
        Some("JY96_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobacterium sp. ML3W nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1538644.KO02_00005";
/// let this_library_node_name2 = "1538644.KO02_23455";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobacterium_sp_ml3w_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobacterium_sp_ml3w_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobacterium_sp_ml3w_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobacterium_sp_ml3w_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1538644"]),
        None,
        Some("."),
        Some("KO02_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Treponema sp. OMZ838 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1539298.JO41_00010";
/// let this_library_node_name2 = "1539298.JO41_12910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_treponema_sp_omz838_node_name(this_library_node_name1));
/// assert!(is_valid_string_treponema_sp_omz838_node_name(this_library_node_name2));
/// assert!(!is_valid_string_treponema_sp_omz838_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_treponema_sp_omz838_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1539298"]),
        None,
        Some("."),
        Some("JO41_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Deinococcus sp. YIM77859 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1540221.JQNI01000001_gene466";
/// let this_library_node_name2 = "1540221.JQNI01000004_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_deinococcus_sp_yim77859_node_name(this_library_node_name1));
/// assert!(is_valid_string_deinococcus_sp_yim77859_node_name(this_library_node_name2));
/// assert!(!is_valid_string_deinococcus_sp_yim77859_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_deinococcus_sp_yim77859_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1540221"]),
        None,
        Some("."),
        Some("JQNI0100000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Clostridium sp. KNHs214 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1540257.JQMW01000001_gene1340";
/// let this_library_node_name2 = "1540257.JQMW01000014_gene99";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_clostridium_sp_knhs214_node_name(this_library_node_name1));
/// assert!(is_valid_string_clostridium_sp_knhs214_node_name(this_library_node_name2));
/// assert!(!is_valid_string_clostridium_sp_knhs214_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_clostridium_sp_knhs214_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1540257"]),
        None,
        Some("."),
        Some("JQMW010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Myxosarcina sp. GI1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1541065.JRFE01000001_gene2504";
/// let this_library_node_name2 = "1541065.JRFE01000076_gene4157";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_myxosarcina_sp_gi1_node_name(this_library_node_name1));
/// assert!(is_valid_string_myxosarcina_sp_gi1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_myxosarcina_sp_gi1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_myxosarcina_sp_gi1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1541065"]),
        None,
        Some("."),
        Some("JRFE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mollicutes bacterium HR1 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1541959.KQ51_00006";
/// let this_library_node_name2 = "1541959.KQ51_01854";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mollicutes_bacterium_hr1_node_name(this_library_node_name1));
/// assert!(is_valid_string_mollicutes_bacterium_hr1_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mollicutes_bacterium_hr1_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mollicutes_bacterium_hr1_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1541959"]),
        None,
        Some("."),
        Some("KQ51_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Mollicutes bacterium HR2 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1541960.KQ78_00001";
/// let this_library_node_name2 = "1541960.KQ78_02284";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_mollicutes_bacterium_hr2_node_name(this_library_node_name1));
/// assert!(is_valid_string_mollicutes_bacterium_hr2_node_name(this_library_node_name2));
/// assert!(!is_valid_string_mollicutes_bacterium_hr2_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_mollicutes_bacterium_hr2_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1541960"]),
        None,
        Some("."),
        Some("KQ78_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus sp. wkB10 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1545701.LACWKB10_0008";
/// let this_library_node_name2 = "1545701.LACWKB10_2015";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_sp_wkb10_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_sp_wkb10_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_sp_wkb10_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_sp_wkb10_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1545701"]),
        None,
        Some("."),
        Some("LACWKB10_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Lactobacillus sp. wkB8 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1545702.LACWKB8_0001";
/// let this_library_node_name2 = "1545702.LACWKB8_1841";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_lactobacillus_sp_wkb8_node_name(this_library_node_name1));
/// assert!(is_valid_string_lactobacillus_sp_wkb8_node_name(this_library_node_name2));
/// assert!(!is_valid_string_lactobacillus_sp_wkb8_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_lactobacillus_sp_wkb8_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1545702"]),
        None,
        Some("."),
        Some("LACWKB8_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. 3524ZXX nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1545915.JROG01000001_gene109";
/// let this_library_node_name2 = "1545915.JROG01000035_gene50";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_3524zxx_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_3524zxx_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_3524zxx_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_3524zxx_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1545915"]),
        None,
        Some("."),
        Some("JROG010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Hoeflea sp. BAL378 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1547437.LL06_00015";
/// let this_library_node_name2 = "1547437.LL06_26910";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_hoeflea_sp_bal378_node_name(this_library_node_name1));
/// assert!(is_valid_string_hoeflea_sp_bal378_node_name(this_library_node_name2));
/// assert!(!is_valid_string_hoeflea_sp_bal378_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_hoeflea_sp_bal378_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1547437"]),
        None,
        Some("."),
        Some("LL06_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Francisella sp. FSC1006 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1547445.LO80_00005";
/// let this_library_node_name2 = "1547445.LO80_09825";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_francisella_sp_fsc1006_node_name(this_library_node_name1));
/// assert!(is_valid_string_francisella_sp_fsc1006_node_name(this_library_node_name2));
/// assert!(!is_valid_string_francisella_sp_fsc1006_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_francisella_sp_fsc1006_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1547445"]),
        None,
        Some("."),
        Some("LO80_0"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Helicobacter sp. MIT115569 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1548151.LS70_00005";
/// let this_library_node_name2 = "1548151.LS70_10675";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_helicobacter_sp_mit115569_node_name(this_library_node_name1));
/// assert!(is_valid_string_helicobacter_sp_mit115569_node_name(this_library_node_name2));
/// assert!(!is_valid_string_helicobacter_sp_mit115569_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_helicobacter_sp_mit115569_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1548151"]),
        None,
        Some("."),
        Some("LS70_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Campylobacter sp. MIT975078 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1548153.LR59_00005";
/// let this_library_node_name2 = "1548153.LR59_13820";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_campylobacter_sp_mit975078_node_name(this_library_node_name1));
/// assert!(is_valid_string_campylobacter_sp_mit975078_node_name(this_library_node_name2));
/// assert!(!is_valid_string_campylobacter_sp_mit975078_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_campylobacter_sp_mit975078_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1548153"]),
        None,
        Some("."),
        Some("LR59_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas taxi nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1549858.MC45_00035";
/// let this_library_node_name2 = "1549858.MC45_18475";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_taxi_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_taxi_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_taxi_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_taxi_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1549858"]),
        None,
        Some("."),
        Some("MC45_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingomonas sp. 37zxx nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1550073.JROH01000001_gene504";
/// let this_library_node_name2 = "1550073.JROH01000141_gene3341";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingomonas_sp_37zxx_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingomonas_sp_37zxx_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingomonas_sp_37zxx_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingomonas_sp_37zxx_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1550073"]),
        None,
        Some("."),
        Some("JROH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sphingobacteriaceae bacterium DW12 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1550091.JROE01000001_gene3965";
/// let this_library_node_name2 = "1550091.JROE01000078_gene3326";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sphingobacteriaceae_bacterium_dw12_node_name(this_library_node_name1));
/// assert!(is_valid_string_sphingobacteriaceae_bacterium_dw12_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sphingobacteriaceae_bacterium_dw12_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sphingobacteriaceae_bacterium_dw12_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1550091"]),
        None,
        Some("."),
        Some("JROE010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Listeriaceae bacterium FSLA50281 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1552123.EP57_00005";
/// let this_library_node_name2 = "1552123.EP57_16695";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_listeriaceae_bacterium_fsla50281_node_name(this_library_node_name1));
/// assert!(is_valid_string_listeriaceae_bacterium_fsla50281_node_name(this_library_node_name2));
/// assert!(!is_valid_string_listeriaceae_bacterium_fsla50281_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_listeriaceae_bacterium_fsla50281_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1552123"]),
        None,
        Some("."),
        Some("EP57_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Xanthomonas sp. Nyagatare nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1552758.NC00_00005";
/// let this_library_node_name2 = "1552758.NC00_20595";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_xanthomonas_sp_nyagatare_node_name(this_library_node_name1));
/// assert!(is_valid_string_xanthomonas_sp_nyagatare_node_name(this_library_node_name2));
/// assert!(!is_valid_string_xanthomonas_sp_nyagatare_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_xanthomonas_sp_nyagatare_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1552758"]),
        None,
        Some("."),
        Some("NC00_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Caenorhabditis tropicalis nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1561998.Csp11.Scaffold0.g1.t1";
/// let this_library_node_name2 = "1561998.Csp11.Scaffold99.g549.t1";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_caenorhabditis_tropicalis_node_name(this_library_node_name1));
/// assert!(is_valid_string_caenorhabditis_tropicalis_node_name(this_library_node_name2));
/// assert!(!is_valid_string_caenorhabditis_tropicalis_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_caenorhabditis_tropicalis_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1561998"]),
        None,
        Some("."),
        Some("Csp11"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Burkholderiaceae sp. Mortierella nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1562701.BBOF01000001_gene1839";
/// let this_library_node_name2 = "1562701.BBOF01000097_gene725";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_burkholderiaceae_sp_mortierella_node_name(this_library_node_name1));
/// assert!(is_valid_string_burkholderiaceae_sp_mortierella_node_name(this_library_node_name2));
/// assert!(!is_valid_string_burkholderiaceae_sp_mortierella_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_burkholderiaceae_sp_mortierella_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1562701"]),
        None,
        Some("."),
        Some("BBOF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Shewanella sp. ECSMB14101 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1565129.JSFF01000001_gene1000";
/// let this_library_node_name2 = "1565129.JSFF01000076_gene468";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_shewanella_sp_ecsmb14101_node_name(this_library_node_name1));
/// assert!(is_valid_string_shewanella_sp_ecsmb14101_node_name(this_library_node_name2));
/// assert!(!is_valid_string_shewanella_sp_ecsmb14101_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_shewanella_sp_ecsmb14101_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1565129"]),
        None,
        Some("."),
        Some("JSFF010000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Sulfurospirillum sp. MES nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1565314.OA34_00005";
/// let this_library_node_name2 = "1565314.OA34_13410";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_sulfurospirillum_sp_mes_node_name(this_library_node_name1));
/// assert!(is_valid_string_sulfurospirillum_sp_mes_node_name(this_library_node_name2));
/// assert!(!is_valid_string_sulfurospirillum_sp_mes_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_sulfurospirillum_sp_mes_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1565314"]),
        None,
        Some("."),
        Some("OA34_"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Paracoccus sp. PAMC22219 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1569209.BBPH01000001_gene1000";
/// let this_library_node_name2 = "1569209.BBPH01000265_gene1060";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_paracoccus_sp_pamc22219_node_name(this_library_node_name1));
/// assert!(is_valid_string_paracoccus_sp_pamc22219_node_name(this_library_node_name2));
/// assert!(!is_valid_string_paracoccus_sp_pamc22219_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_paracoccus_sp_pamc22219_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1569209"]),
        None,
        Some("."),
        Some("BBPH01000"),
        None,
        None,
    )
    .is_ok()
}

#[automatically_generated_function]
/// Returns whether the given node name respects the STRING Dickeya sp. 2B12 nodes pattern.
///
/// # Arguments
/// * `node_name`: &str - Node name to check pattern with.
///
/// # Example
/// To validate a node you can use:
/// ```rust
/// # use graph::*;
/// let this_library_node_name1 = "1577887.JSYG01000001_gene667";
/// let this_library_node_name2 = "1577887.JSYG01000076_gene2257";
/// let not_this_library_node_name = "PizzaQuattroStagioni";
/// assert!(is_valid_string_dickeya_sp_2b12_node_name(this_library_node_name1));
/// assert!(is_valid_string_dickeya_sp_2b12_node_name(this_library_node_name2));
/// assert!(!is_valid_string_dickeya_sp_2b12_node_name(not_this_library_node_name));
/// ```
pub fn is_valid_string_dickeya_sp_2b12_node_name(node_name: &str) -> bool {
    is_valid_node_name_from_seeds(
        node_name,
        Some(&["1577887"]),
        None,
        Some("."),
        Some("JSYG010000"),
        None,
        None,
    )
    .is_ok()
}
