Struct EmailOptions 

pub struct EmailOptions { /* private fields */ }

Configuration for email validation options.

This allows customization of email format validation behavior beyond the default JSON Schema spec requirements. For example, you can configure stricter validation that rejects addresses like “missing@domain” which are technically valid per the spec but may not be desirable in real-world usage.

Example

use jsonschema::EmailOptions;
use serde_json::json;

let schema = json!({"format": "email", "type": "string"});
let validator = jsonschema::options()
    .with_email_options(
        EmailOptions::default()
            .with_required_tld()
            .without_display_text()
    )
    .should_validate_formats(true)
    .build(&schema)
    .expect("A valid schema");

// Stricter validation rejects addresses without TLD
assert!(!validator.is_valid(&json!("user@localhost")));
// And rejects display text
assert!(!validator.is_valid(&json!("Name <user@example.com>")));
// But accepts valid emails with TLD
assert!(validator.is_valid(&json!("user@example.com")));

Implementations

impl EmailOptions

pub const fn with_minimum_sub_domains(self, min: usize) -> Self

Set the minimum number of domain segments that must exist to parse successfully.

Example

use jsonschema::EmailOptions;
use serde_json::json;

let schema = json!({"format": "email", "type": "string"});
let validator = jsonschema::options()
    .with_email_options(EmailOptions::default().with_minimum_sub_domains(3))
    .should_validate_formats(true)
    .build(&schema)
    .expect("A valid schema");

// Requires 3+ domain segments
assert!(!validator.is_valid(&json!("user@example.com")));
assert!(validator.is_valid(&json!("user@sub.example.com")));

pub const fn with_no_minimum_sub_domains(self) -> Self

Set the minimum number of domain segments to zero, allowing single-segment domains like “localhost”.

Example

use jsonschema::EmailOptions;
use serde_json::json;

let schema = json!({"format": "email", "type": "string"});
let validator = jsonschema::options()
    .with_email_options(EmailOptions::default().with_no_minimum_sub_domains())
    .should_validate_formats(true)
    .build(&schema)
    .expect("A valid schema");

// Allows single-segment domains
assert!(validator.is_valid(&json!("user@localhost")));
assert!(validator.is_valid(&json!("user@example.com")));

pub const fn with_required_tld(self) -> Self

Require a domain name with a top-level domain (TLD).

This sets the minimum number of domain segments to two, effectively requiring addresses like “user@example.com” instead of “user@localhost”.

Example

use jsonschema::EmailOptions;
use serde_json::json;

let schema = json!({"format": "email", "type": "string"});
let validator = jsonschema::options()
    .with_email_options(EmailOptions::default().with_required_tld())
    .should_validate_formats(true)
    .build(&schema)
    .expect("A valid schema");

// Requires TLD
assert!(!validator.is_valid(&json!("user@localhost")));
assert!(validator.is_valid(&json!("user@example.com")));

pub const fn with_domain_literal(self) -> Self

Allow domain literals (e.g., email@[127.0.0.1] or email@[IPv6:2001:db8::1]).

This is enabled by default.

Example

use jsonschema::EmailOptions;
use serde_json::json;

let schema = json!({"format": "email", "type": "string"});
let validator = jsonschema::options()
    .with_email_options(EmailOptions::default().with_domain_literal())
    .should_validate_formats(true)
    .build(&schema)
    .expect("A valid schema");

// Domain literals are allowed
assert!(validator.is_valid(&json!("email@[127.0.0.1]")));
assert!(validator.is_valid(&json!("user@example.com")));

pub const fn without_domain_literal(self) -> Self

Disallow domain literals, requiring regular domain names only.

Example

use jsonschema::EmailOptions;
use serde_json::json;

let schema = json!({"format": "email", "type": "string"});
let validator = jsonschema::options()
    .with_email_options(EmailOptions::default().without_domain_literal())
    .should_validate_formats(true)
    .build(&schema)
    .expect("A valid schema");

// Domain literals are rejected
assert!(!validator.is_valid(&json!("email@[127.0.0.1]")));
assert!(validator.is_valid(&json!("user@example.com")));

pub const fn with_display_text(self) -> Self

Allow display text (e.g., Simon <simon@example.com>).

This is enabled by default.

Example

use jsonschema::EmailOptions;
use serde_json::json;

let schema = json!({"format": "email", "type": "string"});
let validator = jsonschema::options()
    .with_email_options(EmailOptions::default().with_display_text())
    .should_validate_formats(true)
    .build(&schema)
    .expect("A valid schema");

// Display text is allowed
assert!(validator.is_valid(&json!("Simon <simon@example.com>")));
assert!(validator.is_valid(&json!("simon@example.com")));

pub const fn without_display_text(self) -> Self

Disallow display text, requiring plain email addresses only.

Example

use jsonschema::EmailOptions;
use serde_json::json;

let schema = json!({"format": "email", "type": "string"});
let validator = jsonschema::options()
    .with_email_options(EmailOptions::default().without_display_text())
    .should_validate_formats(true)
    .build(&schema)
    .expect("A valid schema");

// Display text is rejected
assert!(!validator.is_valid(&json!("Simon <simon@example.com>")));
assert!(validator.is_valid(&json!("simon@example.com")));

Trait Implementations

impl Clone for EmailOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EmailOptions

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

Formats the value using the given formatter.

impl Default for EmailOptions

fn default() -> Self

Returns the “default value” for a type.

impl From<Options> for EmailOptions

fn from(options: EmailAddressOptions) -> Self

Converts to this type from the input type.