import * as assert from "../../../../main/generated/sync/assert/maybe/string";

export function promiseMaybeString (name : string, mixed : any) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeString(name, mixed));
    });
}


export function promiseMaybeMinLength (name : string, mixed : any, min : number) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeMinLength(name, mixed, min));
    });
}

export function promiseMaybeMinLengthHandler (min : number) : (name : string, mixed : any) => Promise<null|undefined|(string)> {
    return (name : string, mixed : any) : Promise<null|undefined|(string)> => {
        return promiseMaybeMinLength(name, mixed, min);
    };
}


export function promiseMaybeMaxLength (name : string, mixed : any, max : number) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeMaxLength(name, mixed, max));
    });
}

export function promiseMaybeMaxLengthHandler (max : number) : (name : string, mixed : any) => Promise<null|undefined|(string)> {
    return (name : string, mixed : any) : Promise<null|undefined|(string)> => {
        return promiseMaybeMaxLength(name, mixed, max);
    };
}


export function promiseMaybeLength (name : string, mixed : any, args : { min? : number, max? : number }) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeLength(name, mixed, args));
    });
}

export function promiseMaybeLengthHandler (args : { min? : number, max? : number }) : (name : string, mixed : any) => Promise<null|undefined|(string)> {
    return (name : string, mixed : any) : Promise<null|undefined|(string)> => {
        return promiseMaybeLength(name, mixed, args);
    };
}


export function promiseMaybeNonEmpty (name : string, mixed : any) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeNonEmpty(name, mixed));
    });
}


export function promiseMaybeContains (name : string, mixed : any, x : string) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeContains(name, mixed, x));
    });
}

export function promiseMaybeContainsHandler (x : string) : (name : string, mixed : any) => Promise<null|undefined|(string)> {
    return (name : string, mixed : any) : Promise<null|undefined|(string)> => {
        return promiseMaybeContains(name, mixed, x);
    };
}


export function promiseMaybeNoDuplicate (name : string, mixed : any) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeNoDuplicate(name, mixed));
    });
}


export function promiseMaybeNotAllWhitespace (name : string, mixed : any) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeNotAllWhitespace(name, mixed));
    });
}


export function promiseMaybeNonEmptyAndNotAllWhitespace (name : string, mixed : any) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeNonEmptyAndNotAllWhitespace(name, mixed));
    });
}


export function promiseMaybeMatch (name : string, mixed : any, regex : RegExp) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeMatch(name, mixed, regex));
    });
}

export function promiseMaybeMatchHandler (regex : RegExp) : (name : string, mixed : any) => Promise<null|undefined|(string)> {
    return (name : string, mixed : any) : Promise<null|undefined|(string)> => {
        return promiseMaybeMatch(name, mixed, regex);
    };
}


export function promiseMaybeEmail (name : string, mixed : any) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeEmail(name, mixed));
    });
}


export function promiseMaybeNotOneOf<T extends string> (name : string, mixed : any, arr : T[]) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeNotOneOf(name, mixed, arr));
    });
}

export function promiseMaybeNotOneOfHandler<T extends string> (arr : T[]) : (name : string, mixed : any) => Promise<null|undefined|(string)> {
    return (name : string, mixed : any) : Promise<null|undefined|(string)> => {
        return promiseMaybeNotOneOf(name, mixed, arr);
    };
}


export function promiseMaybeBase64 (name : string, mixed : any) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeBase64(name, mixed));
    });
}


export function promiseMaybeJson (name : string, mixed : any) : Promise<null|undefined|(string)> {
    return new Promise<null|undefined|(string)>((resolve) => {
        resolve(assert.assertMaybeJson(name, mixed));
    });
}