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

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


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


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

export function assertMaybeArrayOfDictionaryOfBeforeStringHandler (x : Date) : (name : string, mixed : any) => (null|undefined|(({ [key : string] : string })[]))|never {
    return (name : string, mixed : any) : (null|undefined|(({ [key : string] : string })[]))|never => {
        return assertMaybeArrayOfDictionaryOfBeforeString(name, mixed, x);
    };
}


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

export function assertMaybeArrayOfDictionaryOfAfterStringHandler (x : Date) : (name : string, mixed : any) => (null|undefined|(({ [key : string] : string })[]))|never {
    return (name : string, mixed : any) : (null|undefined|(({ [key : string] : string })[]))|never => {
        return assertMaybeArrayOfDictionaryOfAfterString(name, mixed, x);
    };
}


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

export function assertMaybeArrayOfDictionaryOfBeforeOrAtStringHandler (x : Date) : (name : string, mixed : any) => (null|undefined|(({ [key : string] : string })[]))|never {
    return (name : string, mixed : any) : (null|undefined|(({ [key : string] : string })[]))|never => {
        return assertMaybeArrayOfDictionaryOfBeforeOrAtString(name, mixed, x);
    };
}


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

export function assertMaybeArrayOfDictionaryOfAfterOrAtStringHandler (x : Date) : (name : string, mixed : any) => (null|undefined|(({ [key : string] : string })[]))|never {
    return (name : string, mixed : any) : (null|undefined|(({ [key : string] : string })[]))|never => {
        return assertMaybeArrayOfDictionaryOfAfterOrAtString(name, mixed, x);
    };
}


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

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