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

export function promiseString (name : string, mixed : any) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertString(name, mixed));
    });
}


export function promiseMinLength (name : string, mixed : any, min : number) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertMinLength(name, mixed, min));
    });
}

export function promiseMinLengthHandler (min : number) : (name : string, mixed : any) => Promise<string> {
    return (name : string, mixed : any) : Promise<string> => {
        return promiseMinLength(name, mixed, min);
    };
}


export function promiseMaxLength (name : string, mixed : any, max : number) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertMaxLength(name, mixed, max));
    });
}

export function promiseMaxLengthHandler (max : number) : (name : string, mixed : any) => Promise<string> {
    return (name : string, mixed : any) : Promise<string> => {
        return promiseMaxLength(name, mixed, max);
    };
}


export function promiseLength (name : string, mixed : any, args : { min? : number, max? : number }) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertLength(name, mixed, args));
    });
}

export function promiseLengthHandler (args : { min? : number, max? : number }) : (name : string, mixed : any) => Promise<string> {
    return (name : string, mixed : any) : Promise<string> => {
        return promiseLength(name, mixed, args);
    };
}


export function promiseNonEmpty (name : string, mixed : any) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertNonEmpty(name, mixed));
    });
}


export function promiseContains (name : string, mixed : any, x : string) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertContains(name, mixed, x));
    });
}

export function promiseContainsHandler (x : string) : (name : string, mixed : any) => Promise<string> {
    return (name : string, mixed : any) : Promise<string> => {
        return promiseContains(name, mixed, x);
    };
}


export function promiseNoDuplicate (name : string, mixed : any) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertNoDuplicate(name, mixed));
    });
}


export function promiseNotAllWhitespace (name : string, mixed : any) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertNotAllWhitespace(name, mixed));
    });
}


export function promiseNonEmptyAndNotAllWhitespace (name : string, mixed : any) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertNonEmptyAndNotAllWhitespace(name, mixed));
    });
}


export function promiseMatch (name : string, mixed : any, regex : RegExp) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertMatch(name, mixed, regex));
    });
}

export function promiseMatchHandler (regex : RegExp) : (name : string, mixed : any) => Promise<string> {
    return (name : string, mixed : any) : Promise<string> => {
        return promiseMatch(name, mixed, regex);
    };
}


export function promiseEmail (name : string, mixed : any) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertEmail(name, mixed));
    });
}


export function promiseNotOneOf<T extends string> (name : string, mixed : any, arr : T[]) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertNotOneOf(name, mixed, arr));
    });
}

export function promiseNotOneOfHandler<T extends string> (arr : T[]) : (name : string, mixed : any) => Promise<string> {
    return (name : string, mixed : any) : Promise<string> => {
        return promiseNotOneOf(name, mixed, arr);
    };
}


export function promiseBase64 (name : string, mixed : any) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertBase64(name, mixed));
    });
}


export function promiseJson (name : string, mixed : any) : Promise<string> {
    return new Promise<string>((resolve) => {
        resolve(assert.assertJson(name, mixed));
    });
}