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

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


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


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

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


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

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


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

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


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

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


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

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