Collection Arbitraries

/**
 * Generate arrays with configurable min/max length, size, and depth
 * @param arb - Arbitrary for array elements
 * @param constraints - Length, size, and depth constraints
 * @returns Arbitrary generating arrays
 */
function array<T>(arb: Arbitrary<T>, constraints?: ArrayConstraints): Arbitrary<T[]>;

/**
 * Generate arrays with unique elements
 * @param arb - Arbitrary for array elements
 * @param constraints - Length, uniqueness, and comparison constraints
 * @returns Arbitrary generating arrays with unique elements
 */
function uniqueArray<T>(arb: Arbitrary<T>, constraints?: UniqueArrayConstraints<T>): Arbitrary<T[]>;

/**
 * Generate sparse arrays with holes (undefined indices)
 * @param arb - Arbitrary for defined array elements
 * @param constraints - Length, size, and sparsity constraints
 * @returns Arbitrary generating sparse arrays
 */
function sparseArray<T>(arb: Arbitrary<T>, constraints?: SparseArrayConstraints): Arbitrary<T[]>;

interface ArrayConstraints {
  minLength?: number;
  maxLength?: number;
  size?: SizeForArbitrary;
  depthIdentifier?: DepthIdentifier | string;
}

type UniqueArrayConstraints<T> =
  | UniqueArrayConstraintsRecommended<T>
  | UniqueArrayConstraintsCustomCompare<T>
  | UniqueArrayConstraintsCustomCompareSelect<T>;

interface UniqueArraySharedConstraints {
  minLength?: number;
  maxLength?: number;
  size?: SizeForArbitrary;
  depthIdentifier?: DepthIdentifier | string;
}

interface UniqueArrayConstraintsRecommended<T> extends UniqueArraySharedConstraints {
  selector?: (value: T) => unknown;
}

interface UniqueArrayConstraintsCustomCompare<T> extends UniqueArraySharedConstraints {
  comparator: (a: T, b: T) => boolean;
}

interface UniqueArrayConstraintsCustomCompareSelect<T> extends UniqueArraySharedConstraints {
  selector: (value: T) => unknown;
  comparator: (a: unknown, b: unknown) => boolean;
}

interface SparseArrayConstraints {
  minNumElements?: number;
  maxNumElements?: number;
  size?: SizeForArbitrary;
  depthIdentifier?: DepthIdentifier | string;
  noTrailingHole?: boolean;
}

import { array, uniqueArray, sparseArray, integer, string, property, assert } from 'fast-check';

// Basic array generation
assert(
  property(array(integer(), { minLength: 1, maxLength: 10 }), (arr) => {
    return arr.length >= 1 && arr.length <= 10;
  })
);

// Unique array with selector
assert(
  property(
    uniqueArray(
      string().map((s) => ({ id: s, value: Math.random() })),
      { selector: (obj) => obj.id }
    ),
    (arr) => {
      const ids = arr.map((obj) => obj.id);
      return ids.length === new Set(ids).size;
    }
  )
);

// Sparse array
assert(
  property(sparseArray(integer(), { maxNumElements: 10 }), (arr) => {
    const defined = arr.filter((_, i) => i in arr);
    return defined.length <= 10;
  })
);

/**
 * Generate ordered subarrays of an original array
 * @param originalArray - Source array
 * @param constraints - Min/max length constraints
 * @returns Arbitrary generating ordered subarrays
 */
function subarray<T>(originalArray: T[], constraints?: SubarrayConstraints): Arbitrary<T[]>;

/**
 * Generate shuffled (unordered) subarrays of an original array
 * @param originalArray - Source array
 * @param constraints - Min/max length constraints
 * @returns Arbitrary generating shuffled subarrays
 */
function shuffledSubarray<T>(originalArray: T[], constraints?: ShuffledSubarrayConstraints): Arbitrary<T[]>;

interface SubarrayConstraints {
  minLength?: number;
  maxLength?: number;
}

interface ShuffledSubarrayConstraints {
  minLength?: number;
  maxLength?: number;
}

import { subarray, shuffledSubarray, property, assert } from 'fast-check';

const original = [1, 2, 3, 4, 5];

// Ordered subarray
assert(
  property(subarray(original), (sub) => {
    // Check all elements from original in same order
    let originalIdx = 0;
    for (const elem of sub) {
      while (originalIdx < original.length && original[originalIdx] !== elem) {
        originalIdx++;
      }
      if (originalIdx >= original.length) return false;
      originalIdx++;
    }
    return true;
  })
);

// Shuffled subarray
assert(
  property(shuffledSubarray(original, { minLength: 2 }), (sub) => {
    return sub.length >= 2 && sub.every((elem) => original.includes(elem));
  })
);

/**
 * Generate tuples by combining multiple arbitraries in order
 * @param arbs - Arbitraries for each tuple element
 * @returns Arbitrary generating tuples
 */
function tuple<Ts extends unknown[]>(
  ...arbs: { [K in keyof Ts]: Arbitrary<Ts[K]> }
): Arbitrary<Ts>;

import { tuple, string, integer, boolean, property, assert } from 'fast-check';

// Generate user records as tuples
assert(
  property(tuple(string(), integer({ min: 0, max: 120 }), boolean()), ([name, age, active]) => {
    return typeof name === 'string' && typeof age === 'number' && typeof active === 'boolean';
  })
);

/**
 * Generate Set instances with unique elements
 * @param arb - Arbitrary for set elements
 * @param constraints - Size and comparison constraints
 * @returns Arbitrary generating Set instances
 */
function set<T>(arb: Arbitrary<T>, constraints?: SetConstraints): Arbitrary<Set<T>>;

/**
 * Generate Map instances with unique keys
 * @param keyArb - Arbitrary for map keys
 * @param valueArb - Arbitrary for map values
 * @param constraints - Size and comparison constraints
 * @returns Arbitrary generating Map instances
 */
function map<K, V>(
  keyArb: Arbitrary<K>,
  valueArb: Arbitrary<V>,
  constraints?: MapConstraints
): Arbitrary<Map<K, V>>;

interface SetConstraints {
  minLength?: number;
  maxLength?: number;
  size?: SizeForArbitrary;
  depthIdentifier?: DepthIdentifier | string;
  comparator?: (a: T, b: T) => boolean;
}

interface MapConstraints {
  minKeys?: number;
  maxKeys?: number;
  size?: SizeForArbitrary;
  depthIdentifier?: DepthIdentifier | string;
  comparator?: (keyA: K, keyB: K) => boolean;
}

import { set, map, integer, string, property, assert } from 'fast-check';

// Generate sets
assert(
  property(set(integer(), { minLength: 1, maxLength: 5 }), (s) => {
    return s.size >= 1 && s.size <= 5;
  })
);

// Generate maps
assert(
  property(map(string(), integer(), { maxKeys: 10 }), (m) => {
    return m.size <= 10;
  })
);

/**
 * Generate infinite streams of values
 * @param arb - Arbitrary for stream elements
 * @returns Arbitrary generating infinite streams
 */
function infiniteStream<T>(arb: Arbitrary<T>): Arbitrary<Stream<T>>;

import { infiniteStream, integer, property, assert } from 'fast-check';

// Take first N elements from infinite stream
assert(
  property(infiniteStream(integer()), (stream) => {
    const first10 = stream.take(10);
    let count = 0;
    for (const _ of first10) count++;
    return count === 10;
  })
);

/**
 * Generate Int8Array instances
 */
function int8Array(constraints?: IntArrayConstraints): Arbitrary<Int8Array>;

/**
 * Generate Uint8Array instances
 */
function uint8Array(constraints?: IntArrayConstraints): Arbitrary<Uint8Array>;

/**
 * Generate Uint8ClampedArray instances
 */
function uint8ClampedArray(constraints?: IntArrayConstraints): Arbitrary<Uint8ClampedArray>;

/**
 * Generate Int16Array instances
 */
function int16Array(constraints?: IntArrayConstraints): Arbitrary<Int16Array>;

/**
 * Generate Uint16Array instances
 */
function uint16Array(constraints?: IntArrayConstraints): Arbitrary<Uint16Array>;

/**
 * Generate Int32Array instances
 */
function int32Array(constraints?: IntArrayConstraints): Arbitrary<Int32Array>;

/**
 * Generate Uint32Array instances
 */
function uint32Array(constraints?: IntArrayConstraints): Arbitrary<Uint32Array>;

/**
 * Generate Float32Array instances
 */
function float32Array(constraints?: Float32ArrayConstraints): Arbitrary<Float32Array>;

/**
 * Generate Float64Array instances
 */
function float64Array(constraints?: Float64ArrayConstraints): Arbitrary<Float64Array>;

/**
 * Generate BigInt64Array instances
 */
function bigInt64Array(constraints?: BigIntArrayConstraints): Arbitrary<BigInt64Array>;

/**
 * Generate BigUint64Array instances
 */
function bigUint64Array(constraints?: BigIntArrayConstraints): Arbitrary<BigUint64Array>;

interface IntArrayConstraints {
  minLength?: number;
  maxLength?: number;
  size?: SizeForArbitrary;
}

interface Float32ArrayConstraints {
  minLength?: number;
  maxLength?: number;
  size?: SizeForArbitrary;
  noDefaultInfinity?: boolean;
  noNaN?: boolean;
}

interface Float64ArrayConstraints {
  minLength?: number;
  maxLength?: number;
  size?: SizeForArbitrary;
  noDefaultInfinity?: boolean;
  noNaN?: boolean;
}

interface BigIntArrayConstraints {
  minLength?: number;
  maxLength?: number;
  size?: SizeForArbitrary;
  min?: bigint;
  max?: bigint;
}

import {
  int8Array,
  uint8Array,
  float32Array,
  bigInt64Array,
  property,
  assert,
} from 'fast-check';

// Int8 arrays
assert(
  property(int8Array({ minLength: 5, maxLength: 10 }), (arr) => {
    return arr.length >= 5 && arr.length <= 10 && arr.every((v) => v >= -128 && v <= 127);
  })
);

// Uint8 arrays (useful for binary data)
assert(
  property(uint8Array(), (arr) => {
    return arr.every((v) => v >= 0 && v <= 255);
  })
);

// Float32 arrays without special values
assert(
  property(
    float32Array({ noNaN: true, noDefaultInfinity: true, maxLength: 100 }),
    (arr) => {
      return arr.every((v) => !isNaN(v) && isFinite(v));
    }
  )
);

// BigInt64 arrays
assert(
  property(bigInt64Array({ minLength: 1 }), (arr) => {
    return arr.length >= 1 && arr.every((v) => typeof v === 'bigint');
  })
);

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

type DepthIdentifier = { readonly name: string };