import { Constructor, GenericCallback } from "../../models.mjs";

//#region src/internal/value/equal.d.ts
/**
 * Options for value equality comparison
 */
type EqualOptions = {
  /**
   * When `true`, strings are compared case-insensitively
   */
  ignoreCase?: boolean;
  /**
   * Keys _(or key expressions)_ to ignore when comparing objects
   */
  ignoreKeys?: string | RegExp | Array<string | RegExp>;
  /**
   * Should `null` and `undefined` be considered equal?
   */
  relaxedNullish?: boolean;
};
/**
 * An equalizer function for comparing values for equality, with predefined options
 *
 * Can be used to compare values, and register or deregister equality comparison handlers for specific classes
 */
type Equalizer = {
  /**
   * Are two strings equal?
   *
   * @param first First string
   * @param second Second string
   * @param ignoreCase If `true`, comparison will be case-insensitive
   * @returns `true` if the strings are equal, otherwise `false`
   */
  (first: string, second: string, ignoreCase?: boolean): boolean;
  /**
   * Are two values equal?
   *
   * @param first First value
   * @param second Second value
   * @returns `true` if the values are equal, otherwise `false`
   */
  (first: unknown, second: unknown): boolean;
  /**
   * Deregister a equality comparison handler for a specific class
   *
   * @param constructor Class constructor
   */
  deregister: <Instance>(constructor: Constructor<Instance>) => void;
  /**
   * Register a equality comparison function for a specific class
   *
   * @param constructor Class constructor
   * @param handler Comparison function
   */
  register: <Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean) => void;
};
/**
 * Deregister a equality comparison handler for a specific class
 *
 * _Available as `deregisterEqualizer` and `equal.deregister`_
 *
 * @param constructor Class constructor
 */
declare function deregisterEqualizer<Instance>(constructor: Constructor<Instance>): void;
/**
 * Are two strings equal?
 *
 * @param first First string
 * @param second Second string
 * @param ignoreCase If `true`, comparison will be case-insensitive
 * @returns `true` if the strings are equal, otherwise `false`
 */
declare function equal(first: string, second: string, ignoreCase?: boolean): boolean;
/**
 * Are two values equal?
 *
 * @param first First value
 * @param second Second value
 * @param options Comparison options
 * @returns `true` if the values are equal, otherwise `false`
 */
declare function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
declare namespace equal {
  var handlers: {
    deregister(constructor: Constructor): void;
    handle(first: unknown, second: unknown, ...parameters: unknown[]): boolean;
    register(constructor: Constructor, handler?: string | GenericCallback): void;
  };
  var deregister: typeof deregisterEqualizer;
  var initialize: typeof initializeEqualizer;
  var register: typeof registerEqualizer;
}
/**
 * Create an equalizer with predefined options
 *
 * _Available as `initializeEqualizer` and `equal.initialize`_
 *
 * @param options Comparison options
 * @returns Equalizer function
 */
declare function initializeEqualizer(options?: EqualOptions): Equalizer;
/**
 * Register a equality comparison function for a specific class
 *
 * _Available as `registerEqualizer` and `equal.register`_
 *
 * @param constructor Class constructor
 * @param handler Comparison function
 */
declare function registerEqualizer<Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean): void;
//#endregion
export { EqualOptions, deregisterEqualizer, equal, initializeEqualizer, registerEqualizer };