/**
 * @description Converting temperatures.
 */
/**
 * @param {number} temperature The temperature you want to convert to Celsius
 * @param {TemperatureUnits} [unit] The temperature unit you want to convert
 *
 * @returns {number}
 */
declare function toCelsius(temperature: number, unit?: TemperatureUnits): number;
/**
 * @param {number} temperature The temperature you want to convert to Celsius
 * @param {TemperatureUnits} [unit] The temperature unit you want to convert
 *
 * @returns {number}
 */
declare function toFahrenheit(temperature: number, unit?: TemperatureUnits): number;
/**
 * @param {number} temperature The temperature you want to convert to Celsius
 * @param {TemperatureUnits} [unit] The temperature unit you want to convert
 *
 * @returns {number}
 */
declare function toKelvin(temperature: number, unit?: TemperatureUnits): number;
/**
 * The temperature units to be used in the `toCelsius`, `toFahrenheit` and `toKelvin` functions
 */
type TemperatureUnits = 'C' | 'F' | 'K';

/**
 * Calculates force (in Newtons) given mass (kg) and acceleration (m/s²).
 * Formula: F = m * a
 * @param mass - mass in kilograms
 * @param acceleration - acceleration in m/s²
 * @returns force in Newtons
 */
declare const force: (mass: number, acceleration: number) => number;
/**
 * Calculates kinetic energy (in Joules) given mass (kg) and velocity (m/s).
 * Formula: KE = 0.5 * m * v²
 * @param mass - mass in kilograms
 * @param velocity - velocity in m/s
 * @returns kinetic energy in Joules
 */
declare const kineticEnergy: (mass: number, velocity: number) => number;
/**
 * Calculates gravitational potential energy (in Joules) given mass (kg) and height (m).
 * Formula: PE = m * g * h, where g (gravitational acceleration) is 9.81 m/s² by default.
 * @param mass - mass in kilograms
 * @param height - height in meters
 * @param g - gravitational acceleration (default: 9.81 m/s²)
 * @returns potential energy in Joules
 */
declare const potentialEnergy: (mass: number, height: number, g?: number) => number;
/**
 * Calculates momentum (in kg·m/s) given mass (kg) and velocity (m/s).
 * Formula: p = m * v
 * @param mass - mass in kilograms
 * @param velocity - velocity in m/s
 * @returns momentum in kg·m/s
 */
declare const momentum: (mass: number, velocity: number) => number;

/**
 * @description Calculate the area of geometric shapes
 */
declare const area: {
    /**
     * @param {number} base Size of the base of the rectangle
     * @param {number} height The height of the rectangle
     *
     * @returns {number} base * height
     */
    rect: (base: number, height: number) => number;
    /**
     * @param {number} base Size of the base of the triangle
     * @param {number} height The height of the triangle
     *
     * @returns {number} (base * height) / 2
     */
    triangle: (base: number, height: number) => number;
    /**
     * @param {number} D larger diagonal
     * @param {number} d smaller diagonal
     *
     * @returns {number} (D * d) / 2
     */
    rhombus: (D: number, d: number) => number;
    /**
     * @param {number} B Larger base
     * @param {number} b Smaller base
     * @param {number} height Trapezoid height
     *
     * @returns {number} ((B + b) * height) / 2
     */
    trapezoid: (B: number, b: number, height: number) => number;
    /**
     * @param {number} radius Circle radius
     *
     * @returns {number} π * (radius * radius)
     */
    circle: (radius: number) => number;
};

declare const PI: number;
/**
 * @param {number} number The value of the number
 *
 * @returns {boolean} If it is even
 */
declare function isEven(number: number): boolean;
/**
 * @param {number} number The value of the number
 *
 * @returns {boolean} If it is odd
 */
declare function isOdd(number: number): boolean;
/**
 * @param {number} x First number
 * @param {number} y Second number
 *
 * @returns {number} The difference value between X and Y
 */
declare function difference(x: number, y: number): number;
/**
 * @param {number} x Target value
 * @param {number} [times] Times that the value can be multiplied by itself
 *
 * @returns {number} The squared value
 */
declare function squared(x: number, times?: number): number;
/**
 * @param {number} C Adjacent Cathetus
 * @param {number} c Opposite Cathetus
 *
 * @returns {number} Value of the Hypotenuse
 */
declare function hypotenuse(C: number, c: number): number;
declare function cathetus(H: number, C: number): number;

interface InterpolationInput {
    function: (input: number) => number;
    value: number;
    points: number[];
}
/**
 * @param {InterpolationInput} input Interpolation input
 *
 * @returns {number} Interpolation result through Newton Interpolation
 */
declare function interpolation(input: InterpolationInput): number;

interface LinearRegressionOutput {
    m: number;
    b: number;
}
interface PolynomialRegressionOutput {
    a: number;
    b: number;
    c: number;
}
interface RegressionOutput {
    linear: LinearRegressionOutput;
    polynomial: PolynomialRegressionOutput;
}
/**
 * @param {number[][]} input Regression input, must be an array of [x, y]
 *
 * @returns {RegressionOutput} Regression result for both linear and polynomial regression
 */
declare function regression(input: number[][]): RegressionOutput;

declare function populationDensity(population: number, area: number): number;
declare function birthRate(birth: number, population: number): number;
declare function deathRate(death: number, population: number): number;
/**
 * The population of popular states of some countries.
 * Last update: Feb 2025
 */
declare const population: {
    br: {
        sp: number;
    };
    us: {
        ny: number;
    };
};

/**
 * Calculates the great-circle distance between two points on Earth using the Haversine formula.
 * @param lat1 - Latitude of the first point in degrees.
 * @param lon1 - Longitude of the first point in degrees.
 * @param lat2 - Latitude of the second point in degrees.
 * @param lon2 - Longitude of the second point in degrees.
 * @param radius - Radius of the Earth in kilometers (default: 6371 km).
 * @returns Distance between the two points in kilometers.
 */
declare const haversineDistance: (lat1: number, lon1: number, lat2: number, lon2: number, radius?: number) => number;
/**
 * Calculates the initial bearing (forward azimuth) from the first point to the second point.
 * @param lat1 - Latitude of the first point in degrees.
 * @param lon1 - Longitude of the first point in degrees.
 * @param lat2 - Latitude of the second point in degrees.
 * @param lon2 - Longitude of the second point in degrees.
 * @returns Bearing in degrees from North (0° to 360°).
 */
declare const calculateBearing: (lat1: number, lon1: number, lat2: number, lon2: number) => number;
/**
 * Calculates the midpoint between two geographical coordinates.
 * @param lat1 - Latitude of the first point in degrees.
 * @param lon1 - Longitude of the first point in degrees.
 * @param lat2 - Latitude of the second point in degrees.
 * @param lon2 - Longitude of the second point in degrees.
 * @returns An object containing the latitude and longitude of the midpoint in degrees.
 */
declare const midpoint: (lat1: number, lon1: number, lat2: number, lon2: number) => {
    latitude: number;
    longitude: number;
};

export { type InterpolationInput, type LinearRegressionOutput, PI, type PolynomialRegressionOutput, type RegressionOutput, type TemperatureUnits, area, birthRate, calculateBearing, cathetus, deathRate, difference, force, haversineDistance, hypotenuse, interpolation, isEven, isOdd, kineticEnergy, midpoint, momentum, population, populationDensity, potentialEnergy, regression, squared, toCelsius, toFahrenheit, toKelvin };