import { type BoolAnd, type BoolNot, type Brand, type IsNever } from 'ts-type-forge';
import { type Type } from '../type.mjs';
type NumberType = number;
export declare function number(defaultValue?: NumberType): Type<NumberType>;
export declare function number<N extends NumberType, const C extends Constraints>(defaultValue: N & DefaultValueType<N, C>, constraints: C): Type<ConstraintsToResultType<C>>;
type Constraints = Partial<Readonly<{
    finite: true;
    int: true;
    safeInteger: true;
    nonZero: true;
    negative: true;
    nonNegative: true;
    positive: true;
    nonPositive: true;
    gt: NumberType;
    gte: NumberType;
    min: NumberType;
    lt: NumberType;
    lte: NumberType;
    max: NumberType;
    multipleOf: NumberType;
    step: NumberType;
}>>;
/**
 * The set of constraints accepted by {@link number}.
 */
export type NumberTypeConstraints = Constraints;
/**
 * The numeric-range subset of {@link NumberTypeConstraints}. These constraints
 * (`gt`, `gte`, `min`, `lt`, `lte`, `max`, `multipleOf`, `step`) add runtime
 * validation without changing the result brand, so the branded number types
 * under `predefined/brand/number` accept only this subset. To build a different
 * brand from a plain number, use {@link number} with the predicate constraints
 * instead, or the dedicated branded constructor for the target type.
 */
export type NumberRangeConstraints = Pick<NumberTypeConstraints, 'gt' | 'gte' | 'min' | 'lt' | 'lte' | 'max' | 'multipleOf' | 'step'>;
type DefaultValueType<N extends NumberType, C extends Constraints> = DefaultValueWhenNonZeroIsOn<N, C> & DefaultValueWhenNegativeIsOn<N, C> & DefaultValueWhenNonNegativeIsOn<N, C> & DefaultValueWhenPositiveIsOn<N, C> & DefaultValueWhenNonPositiveIsOn<N, C>;
type ConstraintsToResultType<C extends Constraints> = ConstraintsToResultHelperType<ConstraintsToResultBrandKeys<C>>;
type ConstraintsToResultHelperType<R extends Readonly<{
    brandKeys: string;
    brandFalseKeys: string;
}>> = IsNever<R> extends true ? NumberType : Brand<NumberType, R['brandKeys'], R['brandFalseKeys']>;
type ConstraintsToResultBrandKeys<C extends Constraints> = (C extends Readonly<{
    int: true;
}> ? Readonly<{
    brandKeys: 'Int' | 'Finite';
    brandFalseKeys: 'NaNValue';
}> : never) | (C extends Readonly<{
    safeInteger: true;
}> ? Readonly<{
    brandKeys: 'Finite' | 'Int' | 'SafeInt';
    brandFalseKeys: 'NaNValue';
}> : never) | (C extends Readonly<{
    finite: true;
}> ? Readonly<{
    brandKeys: 'Finite';
    brandFalseKeys: 'NaNValue';
}> : never) | (C extends Readonly<{
    nonZero: true;
}> ? Readonly<{
    brandKeys: '!=0';
    brandFalseKeys: 'NaNValue';
}> : never) | (C extends Readonly<{
    negative: true;
}> ? Readonly<{
    brandKeys: '!=0' | '< 2^15' | '< 2^16' | '< 2^31' | '< 2^32' | '<=0';
    brandFalseKeys: '>=0' | 'NaNValue';
}> : never) | (C extends Readonly<{
    nonNegative: true;
}> ? Readonly<{
    brandKeys: '>=0' | '> -2^16' | '> -2^32' | '>= -2^15' | '>= -2^31';
    brandFalseKeys: 'NaNValue';
}> : never) | (C extends Readonly<{
    positive: true;
}> ? Readonly<{
    brandKeys: '>=0' | '!=0' | '> -2^16' | '> -2^32' | '>= -2^15' | '>= -2^31';
    brandFalseKeys: '<=0' | 'NaNValue';
}> : never) | (C extends Readonly<{
    nonPositive: true;
}> ? Readonly<{
    brandKeys: '< 2^15' | '< 2^16' | '< 2^31' | '< 2^32' | '<=0';
    brandFalseKeys: 'NaNValue';
}> : never);
type DefaultValueWhenNonZeroIsOn<N extends NumberType, C extends Constraints> = C extends Readonly<{
    nonZero: true;
}> ? NonZeroNumber<N> : NumberType;
type DefaultValueWhenNegativeIsOn<N extends NumberType, C extends Constraints> = C extends Readonly<{
    negative: true;
}> ? NegativeNumber<N> : NumberType;
type DefaultValueWhenNonNegativeIsOn<N extends NumberType, C extends Constraints> = C extends Readonly<{
    nonNegative: true;
}> ? NonNegativeNumber<N> : NumberType;
type DefaultValueWhenPositiveIsOn<N extends NumberType, C extends Constraints> = C extends Readonly<{
    positive: true;
}> ? PositiveNumber<N> : NumberType;
type DefaultValueWhenNonPositiveIsOn<N extends NumberType, C extends Constraints> = C extends Readonly<{
    nonPositive: true;
}> ? NonPositiveNumber<N> : NumberType;
type NonZeroNumber<N extends NumberType> = NumberType extends N ? NumberType : IsZero<N> extends true ? never : N;
type NegativeNumber<N extends NumberType> = NumberType extends N ? NumberType : IsNegative<N> extends true ? N : never;
type NonNegativeNumber<N extends NumberType> = NumberType extends N ? NumberType : IsNonNegative<N> extends true ? N : never;
type PositiveNumber<N extends NumberType> = NumberType extends N ? NumberType : IsPositive<N> extends true ? N : never;
type NonPositiveNumber<N extends NumberType> = NumberType extends N ? NumberType : IsNonPositive<N> extends true ? N : never;
type IsZero<N extends NumberType> = `${N}` extends '0' ? true : false;
type IsNonZero<N extends NumberType> = IsZero<N> extends true ? false : true;
type IsNegative<N extends NumberType> = `${N}` extends `-${string}` ? true : false;
type IsNonNegative<N extends NumberType> = IsNegative<N> extends true ? false : true;
type IsPositive<N extends NumberType> = BoolAnd<IsNonZero<N>, IsNonNegative<N>>;
type IsNonPositive<N extends NumberType> = BoolNot<IsPositive<N>>;
export {};
//# sourceMappingURL=number.d.mts.map