function validate(
  message: BrandedMessage,
  options?: { now?: Date }
): ValidationResult

type ValidationResult =
  | { valid: true }
  | { valid: false; error: ValidationError };

const message = Siwe.create({
  domain: "example.com",
  address: userAddress,
  uri: "https://example.com",
  chainId: 1,
});

const result = Siwe.validate(message);
if (result.valid) {
  console.log("Message is valid");
} else {
  console.error(result.error.type);
  console.error(result.error.message);
}

const result = Siwe.validate(message);

if (!result.valid) {
  switch (result.error.type) {
    case "expired":
      requestReauth("Session expired");
      break;
    case "not_yet_valid":
      showError("Authentication not yet valid");
      break;
    case "invalid_nonce":
      showError("Invalid authentication token");
      break;
    case "invalid_address":
      showError("Invalid Ethereum address");
      break;
    case "invalid_chain_id":
      showError("Invalid chain ID");
      break;
    case "invalid_timestamp":
      showError("Invalid timestamp format");
      break;
    default:
      showError(`Validation failed: ${result.error.message}`);
  }
}

const message = Siwe.create({
  domain: "example.com",
  address: userAddress,
  uri: "https://example.com",
  chainId: 1,
  expirationTime: "2025-12-31T23:59:59.000Z",
});

// Validate at specific time
const result = Siwe.validate(message, {
  now: new Date("2026-01-01T00:00:00.000Z"),
});
// result.valid === false, error.type === "expired"

const message = Siwe.create({
  domain: "example.com",
  address: userAddress,
  uri: "https://example.com",
  chainId: 1,
  notBefore: "2025-01-01T00:00:00.000Z",
});

const result = Siwe.validate(message, {
  now: new Date("2024-12-31T23:59:59.000Z"),
});
// result.valid === false, error.type === "not_yet_valid"

function validateSession(message: BrandedMessage): boolean {
  const result = Siwe.validate(message, { now: new Date() });
  return result.valid;
}

// Check at session use time
if (!validateSession(storedMessage)) {
  requestReauth();
}

// Always validate before expensive signature verification
const validationResult = Siwe.validate(message);
if (!validationResult.valid) {
  return error(validationResult.error.message);
}

// Only verify signature if structure valid
const verified = Siwe.verify(message, signature);

const message = Siwe.create({ ... });
const result = message.validate();
// Same as Siwe.validate(message)

const resultWithTime = message.validate({ now: new Date() });

app.post('/auth/verify', (req, res) => {
  const message = Siwe.parse(req.body.message);

  const result = Siwe.validate(message);
  if (!result.valid) {
    return res.status(400).json({ error: result.error.message });
  }

  // Continue with nonce and signature verification
});

const CLOCK_SKEW_MS = 30000; // 30 seconds

function validateWithSkew(message: BrandedMessage): ValidationResult {
  const now = new Date(Date.now() - CLOCK_SKEW_MS);
  return Siwe.validate(message, { now });
}