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

export function promiseDictionaryOfPotentiallyUnsafeDate (name : string, mixed : any) : Promise<{ [key : string] : Date }> {
    return new Promise<{ [key : string] : Date }>((resolve) => {
        resolve(assert.assertDictionaryOfPotentiallyUnsafeDate(name, mixed));
    });
}


export function promiseDictionaryOfValidDate (name : string, mixed : any) : Promise<{ [key : string] : Date }> {
    return new Promise<{ [key : string] : Date }>((resolve) => {
        resolve(assert.assertDictionaryOfValidDate(name, mixed));
    });
}


export function promiseDictionaryOfBefore (name : string, mixed : any, x : Date) : Promise<{ [key : string] : Date }> {
    return new Promise<{ [key : string] : Date }>((resolve) => {
        resolve(assert.assertDictionaryOfBefore(name, mixed, x));
    });
}

export function promiseDictionaryOfBeforeHandler (x : Date) : (name : string, mixed : any) => Promise<{ [key : string] : Date }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : Date }> => {
        return promiseDictionaryOfBefore(name, mixed, x);
    };
}


export function promiseDictionaryOfAfter (name : string, mixed : any, x : Date) : Promise<{ [key : string] : Date }> {
    return new Promise<{ [key : string] : Date }>((resolve) => {
        resolve(assert.assertDictionaryOfAfter(name, mixed, x));
    });
}

export function promiseDictionaryOfAfterHandler (x : Date) : (name : string, mixed : any) => Promise<{ [key : string] : Date }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : Date }> => {
        return promiseDictionaryOfAfter(name, mixed, x);
    };
}


export function promiseDictionaryOfBeforeOrAt (name : string, mixed : any, x : Date) : Promise<{ [key : string] : Date }> {
    return new Promise<{ [key : string] : Date }>((resolve) => {
        resolve(assert.assertDictionaryOfBeforeOrAt(name, mixed, x));
    });
}

export function promiseDictionaryOfBeforeOrAtHandler (x : Date) : (name : string, mixed : any) => Promise<{ [key : string] : Date }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : Date }> => {
        return promiseDictionaryOfBeforeOrAt(name, mixed, x);
    };
}


export function promiseDictionaryOfAfterOrAt (name : string, mixed : any, x : Date) : Promise<{ [key : string] : Date }> {
    return new Promise<{ [key : string] : Date }>((resolve) => {
        resolve(assert.assertDictionaryOfAfterOrAt(name, mixed, x));
    });
}

export function promiseDictionaryOfAfterOrAtHandler (x : Date) : (name : string, mixed : any) => Promise<{ [key : string] : Date }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : Date }> => {
        return promiseDictionaryOfAfterOrAt(name, mixed, x);
    };
}


export function promiseDictionaryOfRange (name : string, mixed : any, args : { min? : Date, max? : Date }) : Promise<{ [key : string] : Date }> {
    return new Promise<{ [key : string] : Date }>((resolve) => {
        resolve(assert.assertDictionaryOfRange(name, mixed, args));
    });
}

export function promiseDictionaryOfRangeHandler (args : { min? : Date, max? : Date }) : (name : string, mixed : any) => Promise<{ [key : string] : Date }> {
    return (name : string, mixed : any) : Promise<{ [key : string] : Date }> => {
        return promiseDictionaryOfRange(name, mixed, args);
    };
}