util reference

static sleep(ms: number): Promise<void>;

await util.sleep(250);

static aesDecrypt(encrypted: string, passphrase: string): string;

const plain = util.aesDecrypt(encrypted, passphrase);

static aesEncrypt(payload: string, passphrase: string): string;

const encrypted = util.aesEncrypt('secret', passphrase);

static compareHash(
      password: string | undefined,
      hash: string | undefined,
    ): Promise<boolean>;

const valid = await util.compareHash(password, hash);

static isBase64(input: any): boolean;

const ok = util.isBase64(value);

static decodeBase64(base64String: string): string;

const text = util.decodeBase64(base64String);

static encodeBase64(plainString: string): string;

const encoded = util.encodeBase64('hello');

static generateHash(
      password: string | undefined,
      rounds?: number,
    ): Promise<string>;

const hash = await util.generateHash(password, 10);

static isUUID(input: any): boolean;

const ok = util.isUUID(value);

static randomUUID(): string;

const id = util.randomUUID();

static getUUID(...args: [] | [value: string, namespace: string]): string;

const id = util.getUUID('customer-1', 'customers');

static hashObject(object: any): string;

const hash = util.hashObject({ customerId: 'c-1' });

static sha1(payload: string): string;

const digest = util.sha1('payload');

static sha256(payload: string): string;

const digest = util.sha256('payload');

static md5(payload: string): string;

const digest = util.md5('payload');

static timingSafeEqual(a: string | Buffer, b: string | Buffer): boolean;

const match = util.timingSafeEqual(a, b);

static hmac(
      payload: Uint8Array | string,
      secret: string,
      algorithm?: 'sha1' | 'sha256' | 'sha512',
      encoding?: 'hex' | 'base64',
    ): string;

const signature = util.hmac('payload', secret, 'sha256', 'hex');

static verifyHmacSignature(
      payload: Uint8Array | string,
      signature: string,
      secret: string,
      algorithm?: 'sha1' | 'sha256' | 'sha512',
      encoding?: 'hex' | 'base64',
    ): boolean;

const ok = util.verifyHmacSignature('payload', signature, secret);

static base64UrlEncode(input: Uint8Array | string): string;

const encoded = util.base64UrlEncode('payload');

static base64UrlDecode(input: string): Uint8Array;

const decoded = util.base64UrlDecode(tokenPart);

static randomBytes(size?: number, encoding?: 'hex' | 'base64'): string;

const bytes = util.randomBytes(16, 'hex');

static randomInt(min?: number, max?: number): number;

const n = util.randomInt(1000, 9999);

static randomString(length?: number, alphabet?: string): string;

const token = util.randomString(24);

static otp(length?: number): string;

const code = util.otp(6);

static validate(
      payload: any,
      schema: ValidatorSchemaInput,
    ): ValidationResult<any>;

const result = util.validate(
  api.input()?.body,
  {
    whitelist: false,
    whitelistErrors: false,
    schema: {
      type: 'object',
      required: true,
      objectSchema: [
        { property: 'email', schema: { type: 'string', required: true } },
      ],
    },
  },
);

static jwtDecode(
      token: string,
      options?: { complete?: boolean; json?: boolean },
    ): any;

const payload = util.jwtDecode(token);

static jwtSign(
      payload: string | object,
      secret: string | { key: string; passphrase: string },
      options?: {
        algorithm?:
          | 'HS256'
          | 'HS384'
          | 'HS512'
          | 'RS256'
          | 'RS384'
          | 'RS512'
          | 'ES256'
          | 'ES384'
          | 'ES512'
          | 'PS256'
          | 'PS384'
          | 'PS512'
          | 'none';
        keyid?: string;
        expiresIn?: string | number;
        notBefore?: string | number;
        audience?: string | string[];
        subject?: string;
        issuer?: string;
        jwtid?: string;
        mutatePayload?: boolean;
        noTimestamp?: boolean;
        header?: JWTHeader;
        encoding?: string;
        allowInsecureKeySizes?: boolean;
        allowInvalidAsymmetricKeyTypes?: boolean;
      },
    ): string;

const token = util.jwtSign(
  { sub: 'c-1' },
  secret,
  { expiresIn: '1h' },
);

static jwtVerify(
      token: string,
      secret: string | { key: string; passphrase: string },
      options?: {
        algorithms?: (
          | 'HS256'
          | 'HS384'
          | 'HS512'
          | 'RS256'
          | 'RS384'
          | 'RS512'
          | 'ES256'
          | 'ES384'
          | 'ES512'
          | 'PS256'
          | 'PS384'
          | 'PS512'
          | 'none'
        )[];
        audience?: string | RegExp | Array<string | RegExp>;
        clockTimestamp?: number;
        clockTolerance?: number;
        complete?: boolean;
        issuer?: string | string[];
        ignoreExpiration?: boolean;
        ignoreNotBefore?: boolean;
        jwtid?: string;
        nonce?: string;
        subject?: string;
        maxAge?: string | number;
        allowInvalidAsymmetricKeyTypes?: boolean;
      },
    ): any;

const payload = util.jwtVerify(token, secret);

static rsaDecrypt(
      privateKey: string,
      payload: string,
      passphrase?: string,
    ): string;

const plain = util.rsaDecrypt(privateKey, encrypted, passphrase);

static rsaEncrypt(publicKey: string, payload: string): string;

const encrypted = util.rsaEncrypt(publicKey, 'hello');

static rsaGeneratePair(config?: {
      modulusLength?: number;
      passphrase?: string;
    }): { publicKey: string; privateKey: string };

const pair = util.rsaGeneratePair({ modulusLength: 2048 });

static rsaSign(
      privateKey: string,
      payload: string,
      passphrase?: string,
    ): string;

const signature = util.rsaSign(privateKey, 'hello', passphrase);

static rsaVerify(
      publicKey: string,
      payload: string,
      signature: string,
    ): boolean;

const ok = util.rsaVerify(publicKey, 'hello', signature);