interface StandardGradeItem {
    type: string;
    total: number;
    listening: number;
    reading: number;
    writing: number;
    speaking: number;
}
declare class EnglishConverter {
    static is: (type: string) => boolean;
    static isValid: (item: StandardGradeItem) => boolean;
    static toArray(resume: Record<string, any>): StandardGradeItem[];
    static toValidArray(resume: Record<string, any>): StandardGradeItem[];
    static toObject(items: StandardGradeItem[]): {};
    static defaults(): {
        toefl: null;
        pte: null;
        ielts: null;
        duolingo_english_test: null;
        toefl_listening: null;
        toefl_reading: null;
        toefl_writing: null;
        toefl_speaking: null;
        pte_listening: null;
        pte_reading: null;
        pte_writing: null;
        pte_speaking: null;
        ielts_listening: null;
        ielts_reading: null;
        ielts_writing: null;
        ielts_speaking: null;
        duolingo_english_test_listening: null;
        duolingo_english_test_reading: null;
        duolingo_english_test_writing: null;
        duolingo_english_test_speaking: null;
        toefl_test_score: {
            total: null;
            listening: null;
            reading: null;
            writing: null;
            speaking: null;
        };
        pte_test_score: {
            total: null;
            listening: null;
            reading: null;
            writing: null;
            speaking: null;
        };
        ielts_test_score: {
            total: null;
            listening: null;
            reading: null;
            writing: null;
            speaking: null;
        };
        duolingo_test_score: {
            total: null;
            listening: null;
            reading: null;
            writing: null;
            speaking: null;
        };
    };
}

interface StandardGreItem {
    type: string;
    total: number;
    verbal: number;
    quantitative: number;
}
declare class GreConverter {
    static is: (type: string) => boolean;
    static isValid: (item: StandardGreItem) => boolean;
    static toArray(resume: Record<string, any>): any[];
    static toValidArray(resume: Record<string, any>): any[];
    static toObject(items: StandardGreItem[]): {};
    static defaults(): {
        gre: null;
        gre_verbal: null;
        gre_quantitative: null;
        gre_test_score: {
            total: null;
            verbal: null;
            quantitative: null;
        };
    };
}

interface StandardGmatItem {
    type: string;
    total: number;
    verbal: number;
    quant: number;
    data_insights: number;
}
declare class GmatConverter {
    static is: (type: string) => boolean;
    static isValid: (item: StandardGmatItem) => boolean;
    static toArray(resume: Record<string, any>): any[];
    static toValidArray(resume: Record<string, any>): any[];
    static toObject(items: StandardGmatItem[]): {};
    static defaults(): {
        gmat: null;
        gmat_quant: null;
        gmat_data_insights: null;
        gmat_verbal: null;
        gmat_test_score: {
            total: null;
            quant: null;
            data_insights: null;
            verbal: null;
        };
    };
}

interface StandardItem$4 {
    type: string;
    total: number;
    reading: number;
    english: number;
    math: number;
    science: number;
    writing: number;
}
declare class SatConverter$1 {
    static is: (type: string) => boolean;
    static isValid: (item: StandardItem$4) => boolean;
    static toArray(resume: Record<string, any>): any[];
    static toValidArray(resume: Record<string, any>): any[];
    static toObject(items: StandardItem$4[]): {};
    static toObjectV3(obj: Record<string, any>): {};
    static defaults(): {
        act_test_score: {
            total: number;
            reading: number;
            english: number;
            math: number;
            science: number;
            writing: number;
        };
    };
}

interface StandardItem$3 {
    type: string;
    total: number;
    reading_and_writing: number;
    math: number;
}
declare class SatConverter {
    static is: (type: string) => boolean;
    static isValid: (item: StandardItem$3) => boolean;
    static toArray(resume: Record<string, any>): any[];
    static toValidArray(resume: Record<string, any>): any[];
    static toObject(items: StandardItem$3[]): {};
    static toObjectV3(obj: Record<string, any>): {};
    static defaults(): {
        sat_i_test_score: {
            total: number;
            reading_and_writing: number;
            math: number;
        };
    };
}

interface StandardItem$2 {
    type: string;
    score: number;
    subject: string;
}
declare class ApTestsConverter {
    static is: (type: string) => boolean;
    static isValid: (item: StandardItem$2) => boolean;
    static toArray(resume: Record<string, any>): StandardItem$2[];
    static toValidArray(resume: Record<string, any>): StandardItem$2[];
    static toObject(items: StandardItem$2[]): {
        ap_subject_tests: {
            score: number;
            subject: string;
        }[];
    };
    static defaults(): {
        ap_subject_tests: never[];
    };
}

interface StandardItem$1 {
    type: string;
    study_in_language_and_literature: number;
    language_acquisition: number;
    individuals_and_societies: number;
    experimental_science: number;
    mathematics: number;
    the_arts: number;
}
declare class IbSubjectTestConverter {
    static is: (type: string) => boolean;
    static isValid: (item: StandardItem$1) => boolean;
    static toArray(resume: Record<string, any>): any[];
    static toValidArray(resume: Record<string, any>): any[];
    static toObject(items: StandardItem$1[]): {};
    static toObjectV3(obj: Record<string, any>): {};
    static defaults(): {
        ib_subject_test: {
            type: string;
            study_in_language_and_literature: number;
            language_acquisition: number;
            individuals_and_societies: number;
            experimental_science: number;
            mathematics: number;
            the_arts: number;
        };
    };
}

interface StandardItem {
    type: string;
    subject: string;
    examination_board: string;
    level: string;
}
declare class SubjectTestsConverter {
    static is: (type: string) => boolean;
    static isValid: (item: StandardItem) => boolean;
    static toArray(resume: Record<string, any>): StandardItem[];
    static toValidArray(resume: Record<string, any>): StandardItem[];
    static toObject(items: StandardItem[]): {};
    static defaults(): {
        a_level_subject_tests: never[];
    };
}

declare class ResumeHelper {
    static getDefaults(): {
        gpa: null;
        gpa_raw: null;
        gpa_raw_scale: null;
        class_rank: null;
        high_school: string;
        high_school_grade_level: null;
        summer_school_or_exchange_programs: never[];
        courses: never[];
        undergraduate_courses: never[];
        honors: never[];
        papers: never[];
        extracurricular_activities: never[];
        name: string;
        languages: never[];
        interested_career_or_major: string;
        specialties_and_certifications: never[];
        patents: never[];
        target_countries_or_regions: never[];
        interested_majors: never[];
        preference_tags: {};
        internship_and_work_experiences: never[];
        research_and_project_experiences: never[];
        honors_and_awards: never[];
        other_specialties_activities_experiences: never[];
    };
}

interface ParseRegionTagsOptions {
    region_tags: any[];
    preference_tags: Record<string, any>;
}
interface RegionTagItem {
    region: string;
    type: string;
    key: string;
    value: string;
}
declare class RegionTags {
    static toArray(options: ParseRegionTagsOptions): RegionTagItem[];
}

declare class ProfileHelper {
    static getDefaults(): {
        name: string;
        city: string;
    };
}

declare class ConverterManager {
    static getConverter(type: string): typeof SatConverter$1 | typeof SatConverter | typeof ApTestsConverter | typeof SubjectTestsConverter | undefined;
    static defaults(): {
        sat_i_test_score: {
            total: number;
            reading_and_writing: number;
            math: number;
        };
        ap_subject_tests: never[];
        act_test_score: {
            total: number;
            reading: number;
            english: number;
            math: number;
            science: number;
            writing: number;
        };
        a_level_subject_tests: never[];
    };
}

declare const _default$2: (type: string, field: string) => any;

declare const _default$1: (model: any) => 1 | 0.1;

declare const _default: (type: string, field: string) => any;

export { SubjectTestsConverter as ALevelSubjectTestsConverter, SatConverter$1 as ActConverter, ApTestsConverter, EnglishConverter, GmatConverter, GreConverter, IbSubjectTestConverter, ProfileHelper, RegionTags, ResumeHelper, SatConverter, ConverterManager as StandardizedGradeManager, _default$1 as enStep, _default$2 as minmax, _default as stdMinMax };