Web and Network Arbitraries

/**
 * Generate complete valid URLs
 * @param constraints - URL scheme, authority, and path constraints
 * @returns Arbitrary generating URLs
 */
function webUrl(constraints?: WebUrlConstraints): Arbitrary<string>;

/**
 * Generate web authority parts (domain with optional port and user info)
 * @param constraints - Authority component constraints
 * @returns Arbitrary generating authority strings
 */
function webAuthority(constraints?: WebAuthorityConstraints): Arbitrary<string>;

/**
 * Generate URL paths
 * @param constraints - Path constraints
 * @returns Arbitrary generating URL paths
 */
function webPath(constraints?: WebPathConstraints): Arbitrary<string>;

/**
 * Generate URL path segments
 * @param constraints - Segment constraints
 * @returns Arbitrary generating path segments
 */
function webSegment(constraints?: WebSegmentConstraints): Arbitrary<string>;

/**
 * Generate URL query parameter strings
 * @param constraints - Query parameter constraints
 * @returns Arbitrary generating query strings
 */
function webQueryParameters(constraints?: WebQueryParametersConstraints): Arbitrary<string>;

/**
 * Generate URL fragment identifiers
 * @param constraints - Fragment constraints
 * @returns Arbitrary generating fragment strings
 */
function webFragments(constraints?: WebFragmentsConstraints): Arbitrary<string>;

interface WebUrlConstraints {
  authoritySettings?: WebAuthorityConstraints;
  validSchemes?: string[];
  withFragments?: boolean;
  withQueryParameters?: boolean;
  size?: SizeForArbitrary;
}

interface WebAuthorityConstraints {
  withIPv4?: boolean;
  withIPv4Extended?: boolean;
  withIPv6?: boolean;
  withPort?: boolean;
  withUserInfo?: boolean;
  size?: SizeForArbitrary;
}

interface WebPathConstraints {
  size?: SizeForArbitrary;
}

interface WebSegmentConstraints {
  size?: SizeForArbitrary;
}

interface WebQueryParametersConstraints {
  size?: SizeForArbitrary;
}

interface WebFragmentsConstraints {
  size?: SizeForArbitrary;
}

import {
  webUrl,
  webAuthority,
  webPath,
  webQueryParameters,
  property,
  assert,
} from 'fast-check';

// Generate complete URLs
assert(
  property(webUrl({ validSchemes: ['http', 'https'] }), (url) => {
    return url.startsWith('http://') || url.startsWith('https://');
  })
);

// Generate authority with port
assert(
  property(webAuthority({ withPort: true }), (authority) => {
    return typeof authority === 'string' && authority.length > 0;
  })
);

// Generate paths
assert(
  property(webPath(), (path) => {
    return path.startsWith('/');
  })
);

// Build custom URL
assert(
  property(webAuthority(), webPath(), webQueryParameters(), (auth, path, query) => {
    const url = `https://${auth}${path}?${query}`;
    return new URL(url).href === url;
  })
);

/**
 * Generate valid domain names
 * @param constraints - Domain constraints
 * @returns Arbitrary generating domain names
 */
function domain(constraints?: DomainConstraints): Arbitrary<string>;

/**
 * Generate valid email addresses
 * @param constraints - Email address constraints
 * @returns Arbitrary generating email addresses
 */
function emailAddress(constraints?: EmailAddressConstraints): Arbitrary<string>;

interface DomainConstraints {
  size?: SizeForArbitrary;
}

interface EmailAddressConstraints {
  size?: SizeForArbitrary;
}

import { domain, emailAddress, property, assert } from 'fast-check';

// Domain names
assert(
  property(domain(), (d) => {
    return d.includes('.') && !d.startsWith('.') && !d.endsWith('.');
  })
);

// Email addresses
assert(
  property(emailAddress(), (email) => {
    return email.includes('@') && email.split('@').length === 2;
  })
);

/**
 * Generate valid IPv4 addresses
 * @returns Arbitrary generating IPv4 addresses
 */
function ipV4(): Arbitrary<string>;

/**
 * Generate IPv4 addresses in extended format (including class-based formats)
 * @returns Arbitrary generating extended IPv4 addresses
 */
function ipV4Extended(): Arbitrary<string>;

/**
 * Generate valid IPv6 addresses
 * @returns Arbitrary generating IPv6 addresses
 */
function ipV6(): Arbitrary<string>;

import { ipV4, ipV4Extended, ipV6, property, assert } from 'fast-check';

// IPv4 addresses
assert(
  property(ipV4(), (ip) => {
    const parts = ip.split('.');
    return (
      parts.length === 4 &&
      parts.every((part) => {
        const num = parseInt(part, 10);
        return num >= 0 && num <= 255;
      })
    );
  })
);

// IPv6 addresses
assert(
  property(ipV6(), (ip) => {
    return ip.includes(':');
  })
);

/**
 * Generate UUIDs (versions 1-8 supported)
 * @param constraints - UUID version constraint
 * @returns Arbitrary generating UUIDs in lowercase hexadecimal format
 */
function uuid(constraints?: UuidConstraints): Arbitrary<string>;

/**
 * Generate ULIDs (Universally Unique Lexicographically Sortable Identifiers)
 * @returns Arbitrary generating ULIDs
 */
function ulid(): Arbitrary<string>;

interface UuidConstraints {
  version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
}

import { uuid, ulid, property, assert } from 'fast-check';

// UUIDs (default v4)
assert(
  property(uuid(), (id) => {
    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(id);
  })
);

// Specific UUID version
assert(
  property(uuid({ version: 4 }), (id) => {
    const parts = id.split('-');
    return parts[2].startsWith('4'); // Version 4 identifier
  })
);

// ULIDs
assert(
  property(ulid(), (id) => {
    return /^[0-9A-HJKMNP-TV-Z]{26}$/.test(id);
  })
);

type SizeForArbitrary =
  | 'xsmall'
  | 'small'
  | 'medium'
  | 'large'
  | 'xlarge'
  | '='
  | number
  | { min?: number; max?: number };