import * as assert from "../../../main/generated/sync/assert/date";

export function promisePotentiallyUnsafeDate (name : string, mixed : any) : Promise<Date> {
    return new Promise<Date>((resolve) => {
        resolve(assert.assertPotentiallyUnsafeDate(name, mixed));
    });
}


export function promiseValidDate (name : string, mixed : any) : Promise<Date> {
    return new Promise<Date>((resolve) => {
        resolve(assert.assertValidDate(name, mixed));
    });
}


export function promiseBefore (name : string, mixed : any, x : Date) : Promise<Date> {
    return new Promise<Date>((resolve) => {
        resolve(assert.assertBefore(name, mixed, x));
    });
}

export function promiseBeforeHandler (x : Date) : (name : string, mixed : any) => Promise<Date> {
    return (name : string, mixed : any) : Promise<Date> => {
        return promiseBefore(name, mixed, x);
    };
}


export function promiseAfter (name : string, mixed : any, x : Date) : Promise<Date> {
    return new Promise<Date>((resolve) => {
        resolve(assert.assertAfter(name, mixed, x));
    });
}

export function promiseAfterHandler (x : Date) : (name : string, mixed : any) => Promise<Date> {
    return (name : string, mixed : any) : Promise<Date> => {
        return promiseAfter(name, mixed, x);
    };
}


export function promiseBeforeOrAt (name : string, mixed : any, x : Date) : Promise<Date> {
    return new Promise<Date>((resolve) => {
        resolve(assert.assertBeforeOrAt(name, mixed, x));
    });
}

export function promiseBeforeOrAtHandler (x : Date) : (name : string, mixed : any) => Promise<Date> {
    return (name : string, mixed : any) : Promise<Date> => {
        return promiseBeforeOrAt(name, mixed, x);
    };
}


export function promiseAfterOrAt (name : string, mixed : any, x : Date) : Promise<Date> {
    return new Promise<Date>((resolve) => {
        resolve(assert.assertAfterOrAt(name, mixed, x));
    });
}

export function promiseAfterOrAtHandler (x : Date) : (name : string, mixed : any) => Promise<Date> {
    return (name : string, mixed : any) : Promise<Date> => {
        return promiseAfterOrAt(name, mixed, x);
    };
}


export function promiseRange (name : string, mixed : any, args : { min? : Date, max? : Date }) : Promise<Date> {
    return new Promise<Date>((resolve) => {
        resolve(assert.assertRange(name, mixed, args));
    });
}

export function promiseRangeHandler (args : { min? : Date, max? : Date }) : (name : string, mixed : any) => Promise<Date> {
    return (name : string, mixed : any) : Promise<Date> => {
        return promiseRange(name, mixed, args);
    };
}