import type { Fnode, rule } from "@protontech/fathom";
import type { Features, Inferrer } from "@protontech/ml-inference";
export type AnyRule = ReturnType<typeof rule>;
export type Coeff = [string, number];
export type PerceptronParams = {
    coeffs: Coeff[];
    bias: number;
};
export declare enum FormType {
    LOGIN = "login",
    NOOP = "noop",
    PASSWORD_CHANGE = "password-change",
    RECOVERY = "recovery",
    REGISTER = "register"
}
export declare enum FieldType {
    EMAIL = "email",
    IDENTITY = "identity",
    OTP = "otp",
    PASSWORD_CURRENT = "password",
    PASSWORD_NEW = "new-password",
    USERNAME = "username",
    USERNAME_HIDDEN = "username-hidden",
    CREDIT_CARD = "credit-card"
}
export declare enum CCFieldType {
    NAME = "cc:name",
    FIRSTNAME = "cc:firstname",
    LASTNAME = "cc:lastname",
    NUMBER = "cc:number",
    CSC = "cc:cvc",
    EXP = "cc:exp",
    EXP_YEAR = "cc:exp-year",
    EXP_MONTH = "cc:exp-month"
}
export declare enum IdentityFieldType {
    FULLNAME = "id:fullname",
    FIRSTNAME = "id:firstname",
    MIDDLENAME = "id:middlname",
    LASTNAME = "id:lastname",
    TELEPHONE = "id:tel",
    ADDRESS = "id:address",
    STATE = "id:state",
    CITY = "id:city",
    ZIPCODE = "id:zipcode",
    ORGANIZATION = "id:org",
    COUNTRY = "id:country",
    EMAIL = "id:email"
}
export declare const fieldTypes: FieldType[];
export declare const formTypes: FormType[];
export declare const ccFields: Set<string>;
export declare const identityFields: Set<string>;
export declare const fieldClasses: readonly ["email", "otp", "password", "new-password", "username", "username-hidden"];
export declare const formClasses: readonly ["login", "password-change", "recovery", "register"];
export declare const detectionClasses: readonly ["email", "otp", "password", "new-password", "username", "username-hidden", "login", "password-change", "recovery", "register"];
export declare const abstractDetectionClasses: readonly ["field", "form"];
export type FormClass = (typeof formClasses)[number];
export type FieldClass = (typeof fieldClasses)[number];
export type DetectionClass = (typeof detectionClasses)[number];
export type HeuristicDetectionClass = (typeof abstractDetectionClasses)[number];
export type AbstractFeatures<T = unknown> = Record<string, AbstractFeature<T>>;
export interface AbstractFeature<T = unknown> extends Feature<string, T, AbstractFeatures> {
}
export type InferParentComputeType<P extends AbstractFeatures> = {
    [K in keyof P as P[K]["name"]]: ReturnType<P[K]["compute"]>;
};
export type InferFeatureName<F extends AbstractFeature> = F extends Feature<infer N, unknown, AbstractFeatures> ? N : never;
export type InferFeatureReturnType<F extends AbstractFeature> = F extends Feature<string, infer R, AbstractFeatures> ? R : never;
export type Feature<N extends string, R, P extends AbstractFeatures> = {
    name: N;
    parents: P;
    compute(parents: InferParentComputeType<P>, fnode: Fnode): R;
    private?: true;
};
export type ComputedFeatures<F extends AbstractFeatures> = {
    [K in keyof F as F[K]["name"]]: ReturnType<F[K]["compute"]>;
};
export interface FeatureComputer<F extends AbstractFeatures = AbstractFeatures> {
    compute(fnode: Fnode): ComputedFeatures<F>;
    features: string[];
}
export type ModelProviderRegistry = Record<ModelName, ModelProvider>;
export type ModelName = string;
export type ModelProvider = {
    [Klass in DetectionClass | HeuristicDetectionClass]: Klass extends HeuristicDetectionClass ? {
        featureComputer: FeatureComputer;
    } : {
        featureComputer: FeatureComputer;
        model: Inferrer<Features, number>;
    };
};