type Validator interface {
    Validate(input string) error
}

input := ziva.NewInputTask("Email", "Enter email:").
    WithValidator(ziva.DefaultValidators.Email())

v := ziva.DefaultValidators

// Required field (not empty)
validator := v.Required()

// Minimum length
validator = v.MinLength(5)

// Maximum length
validator = v.MaxLength(20)

// Exact length
validator = v.Length(8)

// Numeric range
validator = v.Range(1, 100)

// Email address
validator := v.Email()

// Optional email (can be empty)
validator = v.OptionalEmail()

// URL address
validator = v.URL()

// Letters and numbers only
validator = v.AlphaNumeric()

// Username
validator = v.Username()

// File/directory path
validator = v.Path()

// IP address (IPv4 or IPv6)
validator := v.IP()

// IPv4 only
validator = v.IPv4()

// IPv6 only
validator = v.IPv6()

// Domain name
validator = v.Domain()

// Port (1-65535)
validator = v.Port()

// Standard password (minimum 8 characters)
validator := v.StandardPassword()

// Strong password (minimum 12 characters, letters, numbers, symbols)
validator = v.StrongPassword()

emailTask := ziva.NewInputTask("Email", "Enter your email:").
    WithValidator(ziva.DefaultValidators.Email())

queue := ziva.NewQueue("Registration")
queue.AddTasks(emailTask)
queue.Run()

fmt.Printf("Email: %s\n", emailTask.GetValue())

portTask := ziva.NewInputTask("Port", "Enter port (1-65535):").
    WithInputType(ziva.InputTypeNumber).
    WithValidator(ziva.DefaultValidators.Port())

queue := ziva.NewQueue("Server Setup")
queue.AddTasks(portTask)
queue.Run()

port, _ := strconv.Atoi(portTask.GetValue())
fmt.Printf("Port: %d\n", port)

passwordTask := ziva.NewInputTask("Password", "Enter password:").
    WithInputType(ziva.InputTypePassword).
    WithValidator(ziva.DefaultValidators.StrongPassword())

queue := ziva.NewQueue("Security")
queue.AddTasks(passwordTask)
queue.Run()

fmt.Println("Password set")

func createUserForm() {
    v := ziva.DefaultValidators

    username := ziva.NewInputTask("Username", "Login (3-20 characters):").
        WithValidator(v.Username())

    email := ziva.NewInputTask("Email", "Email address:").
        WithValidator(v.Email())

    password := ziva.NewInputTask("Password", "Password (min 8 characters):").
        WithInputType(ziva.InputTypePassword).
        WithValidator(v.StandardPassword())

    website := ziva.NewInputTask("Website", "Website (optional):").
        WithValidator(v.OptionalURL())

    queue := ziva.NewQueue("User Registration")
    queue.AddTasks(username, email, password, website)

    if err := queue.Run(); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("User created:\n")
    fmt.Printf("Login: %s\n", username.GetValue())
    fmt.Printf("Email: %s\n", email.GetValue())
    fmt.Printf("Website: %s\n", website.GetValue())
}

// For numbers
task.WithInputType(ziva.InputTypeNumber).
     WithValidator(v.Range(1, 100))

// For passwords
task.WithInputType(ziva.InputTypePassword).
     WithValidator(v.StrongPassword())

// For email
task.WithInputType(ziva.InputTypeEmail).
     WithValidator(v.Email())

type ClearValidator struct{}

func (v *ClearValidator) Validate(input string) error {
    if len(input) < 3 {
        return errors.New("Name must contain at least 3 characters")
    }
    if len(input) > 20 {
        return errors.New("Name must not exceed 20 characters")
    }
    return nil
}

// Different requirements for different environments
func createPasswordValidator(env string) validation.Validator {
    switch env {
    case "production":
        return ziva.DefaultValidators.StrongPassword()
    case "development":
        return ziva.DefaultValidators.StandardPassword()
    default:
        return ziva.DefaultValidators.Required()
    }
}