import * as check from "../../../../../generated/sync/check/dictionary-of/array-of/date";
import {AssertError} from "../../../../../sync/error/AssertError";

export function assertDictionaryOfArrayOfPotentiallyUnsafeDate (name : string, mixed : any) : ({ [key : string] : (Date)[] })|never {
    const error = check.checkDictionaryOfArrayOfPotentiallyUnsafeDate(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertDictionaryOfArrayOfValidDate (name : string, mixed : any) : ({ [key : string] : (Date)[] })|never {
    const error = check.checkDictionaryOfArrayOfValidDate(mixed);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed);
    }
}


export function assertDictionaryOfArrayOfBefore (name : string, mixed : any, x : Date) : ({ [key : string] : (Date)[] })|never {
    const error = check.checkDictionaryOfArrayOfBefore(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertDictionaryOfArrayOfBeforeHandler (x : Date) : (name : string, mixed : any) => ({ [key : string] : (Date)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (Date)[] })|never => {
        return assertDictionaryOfArrayOfBefore(name, mixed, x);
    };
}


export function assertDictionaryOfArrayOfAfter (name : string, mixed : any, x : Date) : ({ [key : string] : (Date)[] })|never {
    const error = check.checkDictionaryOfArrayOfAfter(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertDictionaryOfArrayOfAfterHandler (x : Date) : (name : string, mixed : any) => ({ [key : string] : (Date)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (Date)[] })|never => {
        return assertDictionaryOfArrayOfAfter(name, mixed, x);
    };
}


export function assertDictionaryOfArrayOfBeforeOrAt (name : string, mixed : any, x : Date) : ({ [key : string] : (Date)[] })|never {
    const error = check.checkDictionaryOfArrayOfBeforeOrAt(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertDictionaryOfArrayOfBeforeOrAtHandler (x : Date) : (name : string, mixed : any) => ({ [key : string] : (Date)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (Date)[] })|never => {
        return assertDictionaryOfArrayOfBeforeOrAt(name, mixed, x);
    };
}


export function assertDictionaryOfArrayOfAfterOrAt (name : string, mixed : any, x : Date) : ({ [key : string] : (Date)[] })|never {
    const error = check.checkDictionaryOfArrayOfAfterOrAt(mixed, x);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, x);
    }
}

export function assertDictionaryOfArrayOfAfterOrAtHandler (x : Date) : (name : string, mixed : any) => ({ [key : string] : (Date)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (Date)[] })|never => {
        return assertDictionaryOfArrayOfAfterOrAt(name, mixed, x);
    };
}


export function assertDictionaryOfArrayOfRange (name : string, mixed : any, args : { min? : Date, max? : Date }) : ({ [key : string] : (Date)[] })|never {
    const error = check.checkDictionaryOfArrayOfRange(mixed, args);
    if (error === undefined) {
        return mixed;
    } else {
        throw new AssertError(name, error, mixed, args);
    }
}

export function assertDictionaryOfArrayOfRangeHandler (args : { min? : Date, max? : Date }) : (name : string, mixed : any) => ({ [key : string] : (Date)[] })|never {
    return (name : string, mixed : any) : ({ [key : string] : (Date)[] })|never => {
        return assertDictionaryOfArrayOfRange(name, mixed, args);
    };
}