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

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


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


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

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


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

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


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

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


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

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


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

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