import { Pipe, PipeOutput, ConditionalObjectKeys, PipeInput } from 'valleyed';

declare const signinWithGoogle: (idToken: string) => Promise<{
    email: string;
    email_verified: "true" | "false";
    first_name: string;
    last_name: string;
    picture: string;
    sub: string;
} & Record<string, any>>;
declare const signinWithApple: (idToken: string) => Promise<{
    email?: string;
    sub: string;
    email_verified?: "true" | "false";
    is_private_email?: "true" | "false";
} & Record<string, any>>;
declare const signinWithFacebook: (accessToken: string, fields?: string[]) => Promise<{
    id: string;
    email: string;
    email_verified: "true" | "false";
    name: string;
    picture: {
        data: {
            height: number;
            is_silhouette: boolean;
            url: string;
            width: number;
        };
    };
} & Record<string, any>>;

declare const authProviders_signinWithApple: typeof signinWithApple;
declare const authProviders_signinWithFacebook: typeof signinWithFacebook;
declare const authProviders_signinWithGoogle: typeof signinWithGoogle;
declare namespace authProviders {
  export { authProviders_signinWithApple as signinWithApple, authProviders_signinWithFacebook as signinWithFacebook, authProviders_signinWithGoogle as signinWithGoogle };
}

type CtorParams<T> = ConstructorParameters<T & (abstract new (...args: any[]) => any)>;
type BaseCtorParams<T> = T extends abstract new (...args: infer A) => any ? A : never;
declare function configurable<P extends Pipe<any, any>, Base extends abstract new (...args: any[]) => any>(pipeFn: () => P, base: Base): (abstract new (validated: PipeOutput<P>, ...baseArgs: BaseCtorParams<Base>) => InstanceType<Base> & {
    readonly config: PipeOutput<P>;
}) & {
    readonly Config: PipeOutput<P>;
    create<This extends Function & {
        prototype: any;
    }>(this: This, input: ConditionalObjectKeys<PipeInput<P>>, ...args: CtorParams<This> extends [PipeOutput<P>, ...infer R] ? R : never): This["prototype"];
};

declare const hash: (password: string) => Promise<string>;
declare const compare: (plainPassword: string, hashed: string) => Promise<boolean>;

declare const hash$1_compare: typeof compare;
declare const hash$1_hash: typeof hash;
declare namespace hash$1 {
  export { hash$1_compare as compare, hash$1_hash as hash };
}

declare const parseJSONValue: (data: any) => any;

declare const getMediaDuration: (buffer: Buffer) => Promise<number>;

declare function string(length?: number): string;
declare function number(min?: number, max?: number): number;

declare const random_number: typeof number;
declare const random_string: typeof string;
declare namespace random {
  export { random_number as number, random_string as string };
}

declare const sleep: (ms: number) => Promise<void>;
declare const retry: <T>(cb: () => Promise<{
    done: true;
    value: T;
} | {
    done: false;
}>, tries: number, waitTimeInMs: number) => any;

export { authProviders as AuthProviders, hash$1 as Hash, random as Random, configurable, getMediaDuration, parseJSONValue, retry, sleep };