@alkimia/framework 0.1.0 → 0.1.2

package/components/mocked-services/node_modules/@otplib/core/index.js

@@ -1,491 +0,0 @@
-/**
- * @otplib/core
- *
- * @author Gerald Yeo <contact@fusedthought.com>
- * @version: 12.0.1
- * @license: MIT
- **/
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function objectValues(value) {
-  return Object.keys(value).map(key => value[key]);
-}
-(function (HashAlgorithms) {
-  HashAlgorithms["SHA1"] = "sha1";
-  HashAlgorithms["SHA256"] = "sha256";
-  HashAlgorithms["SHA512"] = "sha512";
-})(exports.HashAlgorithms || (exports.HashAlgorithms = {}));
-const HASH_ALGORITHMS = objectValues(exports.HashAlgorithms);
-(function (KeyEncodings) {
-  KeyEncodings["ASCII"] = "ascii";
-  KeyEncodings["BASE64"] = "base64";
-  KeyEncodings["HEX"] = "hex";
-  KeyEncodings["LATIN1"] = "latin1";
-  KeyEncodings["UTF8"] = "utf8";
-})(exports.KeyEncodings || (exports.KeyEncodings = {}));
-const KEY_ENCODINGS = objectValues(exports.KeyEncodings);
-(function (Strategy) {
-  Strategy["HOTP"] = "hotp";
-  Strategy["TOTP"] = "totp";
-})(exports.Strategy || (exports.Strategy = {}));
-const STRATEGY = objectValues(exports.Strategy);
-const createDigestPlaceholder = () => {
-  throw new Error('Please provide an options.createDigest implementation.');
-};
-function isTokenValid(value) {
-  return /^(\d+)$/.test(value);
-}
-function padStart(value, maxLength, fillString) {
-  if (value.length >= maxLength) {
-    return value;
-  }
-  const padding = Array(maxLength + 1).join(fillString);
-  return `${padding}${value}`.slice(-1 * maxLength);
-}
-function keyuri(options) {
-  const tmpl = `otpauth://${options.type}/{labelPrefix}:{accountName}?secret={secret}{query}`;
-  const params = [];
-  if (STRATEGY.indexOf(options.type) < 0) {
-    throw new Error(`Expecting options.type to be one of ${STRATEGY.join(', ')}. Received ${options.type}.`);
-  }
-  if (options.type === 'hotp') {
-    if (options.counter == null || typeof options.counter !== 'number') {
-      throw new Error('Expecting options.counter to be a number when options.type is "hotp".');
-    }
-    params.push(`&counter=${options.counter}`);
-  }
-  if (options.type === 'totp' && options.step) {
-    params.push(`&period=${options.step}`);
-  }
-  if (options.digits) {
-    params.push(`&digits=${options.digits}`);
-  }
-  if (options.algorithm) {
-    params.push(`&algorithm=${options.algorithm.toUpperCase()}`);
-  }
-  if (options.issuer) {
-    params.push(`&issuer=${encodeURIComponent(options.issuer)}`);
-  }
-  return tmpl.replace('{labelPrefix}', encodeURIComponent(options.issuer || options.accountName)).replace('{accountName}', encodeURIComponent(options.accountName)).replace('{secret}', options.secret).replace('{query}', params.join(''));
-}
-class OTP {
-  constructor(defaultOptions = {}) {
-    this._defaultOptions = Object.freeze({ ...defaultOptions
-    });
-    this._options = Object.freeze({});
-  }
-  create(defaultOptions = {}) {
-    return new OTP(defaultOptions);
-  }
-  clone(defaultOptions = {}) {
-    const instance = this.create({ ...this._defaultOptions,
-      ...defaultOptions
-    });
-    instance.options = this._options;
-    return instance;
-  }
-  get options() {
-    return Object.freeze({ ...this._defaultOptions,
-      ...this._options
-    });
-  }
-  set options(options) {
-    this._options = Object.freeze({ ...this._options,
-      ...options
-    });
-  }
-  allOptions() {
-    return this.options;
-  }
-  resetOptions() {
-    this._options = Object.freeze({});
-  }
-}
-
-function hotpOptionsValidator(options) {
-  if (typeof options.createDigest !== 'function') {
-    throw new Error('Expecting options.createDigest to be a function.');
-  }
-  if (typeof options.createHmacKey !== 'function') {
-    throw new Error('Expecting options.createHmacKey to be a function.');
-  }
-  if (typeof options.digits !== 'number') {
-    throw new Error('Expecting options.digits to be a number.');
-  }
-  if (!options.algorithm || HASH_ALGORITHMS.indexOf(options.algorithm) < 0) {
-    throw new Error(`Expecting options.algorithm to be one of ${HASH_ALGORITHMS.join(', ')}. Received ${options.algorithm}.`);
-  }
-  if (!options.encoding || KEY_ENCODINGS.indexOf(options.encoding) < 0) {
-    throw new Error(`Expecting options.encoding to be one of ${KEY_ENCODINGS.join(', ')}. Received ${options.encoding}.`);
-  }
-}
-const hotpCreateHmacKey = (algorithm, secret, encoding) => {
-  return Buffer.from(secret, encoding).toString('hex');
-};
-function hotpDefaultOptions() {
-  const options = {
-    algorithm: exports.HashAlgorithms.SHA1,
-    createHmacKey: hotpCreateHmacKey,
-    createDigest: createDigestPlaceholder,
-    digits: 6,
-    encoding: exports.KeyEncodings.ASCII
-  };
-  return options;
-}
-function hotpOptions(opt) {
-  const options = { ...hotpDefaultOptions(),
-    ...opt
-  };
-  hotpOptionsValidator(options);
-  return Object.freeze(options);
-}
-function hotpCounter(counter) {
-  const hexCounter = counter.toString(16);
-  return padStart(hexCounter, 16, '0');
-}
-function hotpDigestToToken(hexDigest, digits) {
-  const digest = Buffer.from(hexDigest, 'hex');
-  const offset = digest[digest.length - 1] & 0xf;
-  const binary = (digest[offset] & 0x7f) << 24 | (digest[offset + 1] & 0xff) << 16 | (digest[offset + 2] & 0xff) << 8 | digest[offset + 3] & 0xff;
-  const token = binary % Math.pow(10, digits);
-  return padStart(String(token), digits, '0');
-}
-function hotpDigest(secret, counter, options) {
-  const hexCounter = hotpCounter(counter);
-  const hmacKey = options.createHmacKey(options.algorithm, secret, options.encoding);
-  return options.createDigest(options.algorithm, hmacKey, hexCounter);
-}
-function hotpToken(secret, counter, options) {
-  const hexDigest = options.digest || hotpDigest(secret, counter, options);
-  return hotpDigestToToken(hexDigest, options.digits);
-}
-function hotpCheck(token, secret, counter, options) {
-  if (!isTokenValid(token)) {
-    return false;
-  }
-  const systemToken = hotpToken(secret, counter, options);
-  return token === systemToken;
-}
-function hotpKeyuri(accountName, issuer, secret, counter, options) {
-  return keyuri({
-    algorithm: options.algorithm,
-    digits: options.digits,
-    type: exports.Strategy.HOTP,
-    accountName,
-    counter,
-    issuer,
-    secret
-  });
-}
-class HOTP extends OTP {
-  create(defaultOptions = {}) {
-    return new HOTP(defaultOptions);
-  }
-  allOptions() {
-    return hotpOptions(this.options);
-  }
-  generate(secret, counter) {
-    return hotpToken(secret, counter, this.allOptions());
-  }
-  check(token, secret, counter) {
-    return hotpCheck(token, secret, counter, this.allOptions());
-  }
-  verify(opts) {
-    if (typeof opts !== 'object') {
-      throw new Error('Expecting argument 0 of verify to be an object');
-    }
-    return this.check(opts.token, opts.secret, opts.counter);
-  }
-  keyuri(accountName, issuer, secret, counter) {
-    return hotpKeyuri(accountName, issuer, secret, counter, this.allOptions());
-  }
-}
-
-function parseWindowBounds(win) {
-  if (typeof win === 'number') {
-    return [Math.abs(win), Math.abs(win)];
-  }
-  if (Array.isArray(win)) {
-    const [past, future] = win;
-    if (typeof past === 'number' && typeof future === 'number') {
-      return [Math.abs(past), Math.abs(future)];
-    }
-  }
-  throw new Error('Expecting options.window to be an number or [number, number].');
-}
-function totpOptionsValidator(options) {
-  hotpOptionsValidator(options);
-  parseWindowBounds(options.window);
-  if (typeof options.epoch !== 'number') {
-    throw new Error('Expecting options.epoch to be a number.');
-  }
-  if (typeof options.step !== 'number') {
-    throw new Error('Expecting options.step to be a number.');
-  }
-}
-const totpPadSecret = (secret, encoding, minLength) => {
-  const currentLength = secret.length;
-  const hexSecret = Buffer.from(secret, encoding).toString('hex');
-  if (currentLength < minLength) {
-    const newSecret = new Array(minLength - currentLength + 1).join(hexSecret);
-    return Buffer.from(newSecret, 'hex').slice(0, minLength).toString('hex');
-  }
-  return hexSecret;
-};
-const totpCreateHmacKey = (algorithm, secret, encoding) => {
-  switch (algorithm) {
-    case exports.HashAlgorithms.SHA1:
-      return totpPadSecret(secret, encoding, 20);
-    case exports.HashAlgorithms.SHA256:
-      return totpPadSecret(secret, encoding, 32);
-    case exports.HashAlgorithms.SHA512:
-      return totpPadSecret(secret, encoding, 64);
-    default:
-      throw new Error(`Expecting algorithm to be one of ${HASH_ALGORITHMS.join(', ')}. Received ${algorithm}.`);
-  }
-};
-function totpDefaultOptions() {
-  const options = {
-    algorithm: exports.HashAlgorithms.SHA1,
-    createDigest: createDigestPlaceholder,
-    createHmacKey: totpCreateHmacKey,
-    digits: 6,
-    encoding: exports.KeyEncodings.ASCII,
-    epoch: Date.now(),
-    step: 30,
-    window: 0
-  };
-  return options;
-}
-function totpOptions(opt) {
-  const options = { ...totpDefaultOptions(),
-    ...opt
-  };
-  totpOptionsValidator(options);
-  return Object.freeze(options);
-}
-function totpCounter(epoch, step) {
-  return Math.floor(epoch / step / 1000);
-}
-function totpToken(secret, options) {
-  const counter = totpCounter(options.epoch, options.step);
-  return hotpToken(secret, counter, options);
-}
-function totpEpochsInWindow(epoch, direction, deltaPerEpoch, numOfEpoches) {
-  const result = [];
-  if (numOfEpoches === 0) {
-    return result;
-  }
-  for (let i = 1; i <= numOfEpoches; i++) {
-    const delta = direction * i * deltaPerEpoch;
-    result.push(epoch + delta);
-  }
-  return result;
-}
-function totpEpochAvailable(epoch, step, win) {
-  const bounds = parseWindowBounds(win);
-  const delta = step * 1000;
-  return {
-    current: epoch,
-    past: totpEpochsInWindow(epoch, -1, delta, bounds[0]),
-    future: totpEpochsInWindow(epoch, 1, delta, bounds[1])
-  };
-}
-function totpCheck(token, secret, options) {
-  if (!isTokenValid(token)) {
-    return false;
-  }
-  const systemToken = totpToken(secret, options);
-  return token === systemToken;
-}
-function totpCheckByEpoch(epochs, token, secret, options) {
-  let position = null;
-  epochs.some((epoch, idx) => {
-    if (totpCheck(token, secret, { ...options,
-      epoch
-    })) {
-      position = idx + 1;
-      return true;
-    }
-    return false;
-  });
-  return position;
-}
-function totpCheckWithWindow(token, secret, options) {
-  if (totpCheck(token, secret, options)) {
-    return 0;
-  }
-  const epochs = totpEpochAvailable(options.epoch, options.step, options.window);
-  const backward = totpCheckByEpoch(epochs.past, token, secret, options);
-  if (backward !== null) {
-    return backward * -1;
-  }
-  return totpCheckByEpoch(epochs.future, token, secret, options);
-}
-function totpTimeUsed(epoch, step) {
-  return Math.floor(epoch / 1000) % step;
-}
-function totpTimeRemaining(epoch, step) {
-  return step - totpTimeUsed(epoch, step);
-}
-function totpKeyuri(accountName, issuer, secret, options) {
-  return keyuri({
-    algorithm: options.algorithm,
-    digits: options.digits,
-    step: options.step,
-    type: exports.Strategy.TOTP,
-    accountName,
-    issuer,
-    secret
-  });
-}
-class TOTP extends HOTP {
-  create(defaultOptions = {}) {
-    return new TOTP(defaultOptions);
-  }
-  allOptions() {
-    return totpOptions(this.options);
-  }
-  generate(secret) {
-    return totpToken(secret, this.allOptions());
-  }
-  checkDelta(token, secret) {
-    return totpCheckWithWindow(token, secret, this.allOptions());
-  }
-  check(token, secret) {
-    const delta = this.checkDelta(token, secret);
-    return typeof delta === 'number';
-  }
-  verify(opts) {
-    if (typeof opts !== 'object') {
-      throw new Error('Expecting argument 0 of verify to be an object');
-    }
-    return this.check(opts.token, opts.secret);
-  }
-  timeRemaining() {
-    const options = this.allOptions();
-    return totpTimeRemaining(options.epoch, options.step);
-  }
-  timeUsed() {
-    const options = this.allOptions();
-    return totpTimeUsed(options.epoch, options.step);
-  }
-  keyuri(accountName, issuer, secret) {
-    return totpKeyuri(accountName, issuer, secret, this.allOptions());
-  }
-}
-
-function authenticatorOptionValidator(options) {
-  totpOptionsValidator(options);
-  if (typeof options.keyDecoder !== 'function') {
-    throw new Error('Expecting options.keyDecoder to be a function.');
-  }
-  if (options.keyEncoder && typeof options.keyEncoder !== 'function') {
-    throw new Error('Expecting options.keyEncoder to be a function.');
-  }
-}
-function authenticatorDefaultOptions() {
-  const options = {
-    algorithm: exports.HashAlgorithms.SHA1,
-    createDigest: createDigestPlaceholder,
-    createHmacKey: totpCreateHmacKey,
-    digits: 6,
-    encoding: exports.KeyEncodings.HEX,
-    epoch: Date.now(),
-    step: 30,
-    window: 0
-  };
-  return options;
-}
-function authenticatorOptions(opt) {
-  const options = { ...authenticatorDefaultOptions(),
-    ...opt
-  };
-  authenticatorOptionValidator(options);
-  return Object.freeze(options);
-}
-function authenticatorEncoder(secret, options) {
-  return options.keyEncoder(secret, options.encoding);
-}
-function authenticatorDecoder(secret, options) {
-  return options.keyDecoder(secret, options.encoding);
-}
-function authenticatorGenerateSecret(numberOfBytes, options) {
-  const key = options.createRandomBytes(numberOfBytes, options.encoding);
-  return authenticatorEncoder(key, options);
-}
-function authenticatorToken(secret, options) {
-  return totpToken(authenticatorDecoder(secret, options), options);
-}
-function authenticatorCheckWithWindow(token, secret, options) {
-  return totpCheckWithWindow(token, authenticatorDecoder(secret, options), options);
-}
-class Authenticator extends TOTP {
-  create(defaultOptions = {}) {
-    return new Authenticator(defaultOptions);
-  }
-  allOptions() {
-    return authenticatorOptions(this.options);
-  }
-  generate(secret) {
-    return authenticatorToken(secret, this.allOptions());
-  }
-  checkDelta(token, secret) {
-    return authenticatorCheckWithWindow(token, secret, this.allOptions());
-  }
-  encode(secret) {
-    return authenticatorEncoder(secret, this.allOptions());
-  }
-  decode(secret) {
-    return authenticatorDecoder(secret, this.allOptions());
-  }
-  generateSecret(numberOfBytes = 10) {
-    return authenticatorGenerateSecret(numberOfBytes, this.allOptions());
-  }
-}
-
-exports.Authenticator = Authenticator;
-exports.HASH_ALGORITHMS = HASH_ALGORITHMS;
-exports.HOTP = HOTP;
-exports.KEY_ENCODINGS = KEY_ENCODINGS;
-exports.OTP = OTP;
-exports.STRATEGY = STRATEGY;
-exports.TOTP = TOTP;
-exports.authenticatorCheckWithWindow = authenticatorCheckWithWindow;
-exports.authenticatorDecoder = authenticatorDecoder;
-exports.authenticatorDefaultOptions = authenticatorDefaultOptions;
-exports.authenticatorEncoder = authenticatorEncoder;
-exports.authenticatorGenerateSecret = authenticatorGenerateSecret;
-exports.authenticatorOptionValidator = authenticatorOptionValidator;
-exports.authenticatorOptions = authenticatorOptions;
-exports.authenticatorToken = authenticatorToken;
-exports.createDigestPlaceholder = createDigestPlaceholder;
-exports.hotpCheck = hotpCheck;
-exports.hotpCounter = hotpCounter;
-exports.hotpCreateHmacKey = hotpCreateHmacKey;
-exports.hotpDefaultOptions = hotpDefaultOptions;
-exports.hotpDigestToToken = hotpDigestToToken;
-exports.hotpKeyuri = hotpKeyuri;
-exports.hotpOptions = hotpOptions;
-exports.hotpOptionsValidator = hotpOptionsValidator;
-exports.hotpToken = hotpToken;
-exports.isTokenValid = isTokenValid;
-exports.keyuri = keyuri;
-exports.objectValues = objectValues;
-exports.padStart = padStart;
-exports.totpCheck = totpCheck;
-exports.totpCheckByEpoch = totpCheckByEpoch;
-exports.totpCheckWithWindow = totpCheckWithWindow;
-exports.totpCounter = totpCounter;
-exports.totpCreateHmacKey = totpCreateHmacKey;
-exports.totpDefaultOptions = totpDefaultOptions;
-exports.totpEpochAvailable = totpEpochAvailable;
-exports.totpKeyuri = totpKeyuri;
-exports.totpOptions = totpOptions;
-exports.totpOptionsValidator = totpOptionsValidator;
-exports.totpPadSecret = totpPadSecret;
-exports.totpTimeRemaining = totpTimeRemaining;
-exports.totpTimeUsed = totpTimeUsed;
-exports.totpToken = totpToken;

package/components/mocked-services/node_modules/@otplib/core/package.json

@@ -1,19 +0,0 @@
-{
-  "name": "@otplib/core",
-  "description": "core method for otplib",
-  "version": "12.0.1",
-  "main": "./index.js",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {},
-  "keywords": [
-    "otplib-core"
-  ],
-  "otplib": {},
-  "author": "Gerald Yeo <contact@fusedthought.com>",
-  "license": "MIT",
-  "homepage": "https://yeojz.otplib.dev",
-  "repository": "https://github.com/yeojz/otplib/tree/master/packages/otplib-core",
-  "types": "./index.d.ts"
-}

package/components/mocked-services/node_modules/@otplib/core/totp.d.ts

@@ -1,202 +0,0 @@
-import { CreateHmacKey, KeyEncodings, SecretKey } from './utils';
-import { HOTP, HOTPOptions } from './hotp';
-/**
- * Interface for options used in TOTP.
- *
- * Contains additional options in addition to
- * those within HOTP.
- */
-export interface TOTPOptions<T = string> extends HOTPOptions<T> {
-    /**
-     * The starting time since the JavasSript epoch (seconds) (UNIX epoch * 1000).
-     */
-    epoch: number;
-    /**
-     * Time step (seconds).
-     */
-    step: number;
-    /**
-     * How many windows (x * step) past and future do we consider as valid during check.
-     */
-    window: number | [number, number];
-}
-/**
- * Interface for available epoches derived from
- * the current epoch.
- */
-export interface EpochAvailable {
-    current: number;
-    future: number[];
-    past: number[];
-}
-/**
- * Validates the given [[TOTPOptions]].
- */
-export declare function totpOptionsValidator<T extends TOTPOptions<unknown> = TOTPOptions<unknown>>(options: Readonly<Partial<T>>): void;
-/**
- * Pads the secret to the expected minimum length
- * and returns a hex representation of the string.
- */
-export declare const totpPadSecret: (secret: string, encoding: KeyEncodings, minLength: number) => string;
-/**
- * Takes a TOTP secret and derives the HMAC key
- * for use in token generation.
- *
- * In RFC 6238, the secret / seed length for different algorithms
- * are predefined.
- *
- * - HMAC-SHA1 (20 bytes)
- * - HMAC-SHA256 (32 bytes)
- * - HMAC-SHA512 (64 bytes)
- *
- * @param algorithm - Reference: [[TOTPOptions.algorithm]]
- * @param secret
- * @param encoding - Reference: [[TOTPOptions.encoding]]
- */
-export declare const totpCreateHmacKey: CreateHmacKey;
-/**
- * Returns a set of default options for TOTP at the current epoch.
- */
-export declare function totpDefaultOptions<T extends TOTPOptions<unknown> = TOTPOptions<unknown>>(): Partial<T>;
-/**
- * Takes an TOTP Option object and provides presets for
- * some of the missing required TOTP option fields and validates
- * the resultant options.
- */
-export declare function totpOptions<T extends TOTPOptions<unknown> = TOTPOptions<unknown>>(opt: Partial<T>): Readonly<T>;
-/**
- * Generates the counter based on the current epoch and step.
- * This dynamic counter is used in the HOTP algorithm.
- *
- * @param epoch - Reference: [[TOTPOptions.epoch]]
- * @param step - Reference: [[TOTPOptions.step]]
- */
-export declare function totpCounter(epoch: number, step: number): number;
-/**
- * Generates a Time-based One-time Token (TOTP)
- *
- * tl;dr: TOTP = HOTP + counter based on current time.
- *
- * **References**
- *
- * -   http://tools.ietf.org/html/rfc6238
- * -   http://en.wikipedia.org/wiki/Time-based_One-time_Password_Algorithm
- *
- */
-export declare function totpToken<T extends TOTPOptions<unknown> = TOTPOptions<unknown>>(secret: SecretKey, options: Readonly<T>): string;
-/**
- * Gets a set of epoches derived from
- * the current epoch and the acceptable window.
- *
- * @param epoch - Reference: [[TOTPOptions.epoch]]
- * @param step - Reference: [[TOTPOptions.step]]
- * @param win - Reference: [[TOTPOptions.window]]
- */
-export declare function totpEpochAvailable(epoch: number, step: number, win: number | [number, number]): EpochAvailable;
-/**
- * Checks the given token against the system generated token.
- *
- * **Note**: Token is valid only if it is a number string.
- */
-export declare function totpCheck<T extends TOTPOptions<unknown> = TOTPOptions<unknown>>(token: string, secret: SecretKey, options: Readonly<T>): boolean;
-/**
- * Checks if there is a valid TOTP token in a given list of epoches.
- * Returns the (index + 1) of a valid epoch in the list.
- *
- * @param epochs - List of epochs to check token against
- * @param token - The token to check
- * @param secret - Your secret key.
- * @param options - A TOTPOptions object.
- */
-export declare function totpCheckByEpoch<T extends TOTPOptions = TOTPOptions>(epochs: number[], token: string, secret: SecretKey, options: Readonly<T>): number | null;
-/**
- * Checks the provided OTP token against system generated token
- * with support for checking past or future x * step windows.
- *
- * Return values:
- *
- * - null = check failed
- * - positive number = token at future x * step
- * - negative number = token at past x * step
- *
- * @param token - The token to check
- * @param secret - Your secret key.
- * @param options - A TOTPOptions object.
- */
-export declare function totpCheckWithWindow<T extends TOTPOptions = TOTPOptions>(token: string, secret: SecretKey, options: Readonly<T>): number | null;
-/**
- * Calculates the number of seconds used in the current tick for TOTP.
- *
- * The start of a new token: `timeUsed() === 0`
- *
- * @param epoch - Reference: [[TOTPOptions.epoch]]
- * @param step - Reference: [[TOTPOptions.step]]
- */
-export declare function totpTimeUsed(epoch: number, step: number): number;
-/**
- * Calculates the number of seconds till next tick for TOTP.
- *
- * The start of a new token: `timeRemaining() === step`
- *
- * @param epoch - Reference: [[TOTPOptions.epoch]]
- * @param step - Reference: [[TOTPOptions.step]]
- */
-export declare function totpTimeRemaining(epoch: number, step: number): number;
-/**
- * Generates a [keyuri](../#keyuri) from options provided
- * and it's type set to TOTP.
- */
-export declare function totpKeyuri<T extends TOTPOptions<unknown> = TOTPOptions<unknown>>(accountName: string, issuer: string, secret: SecretKey, options: Readonly<T>): string;
-/**
- * A class wrapper containing all TOTP methods.
- */
-export declare class TOTP<T extends TOTPOptions = TOTPOptions> extends HOTP<T> {
-    /**
-     * Creates a new instance with all defaultOptions and options reset.
-     */
-    create(defaultOptions?: Partial<T>): TOTP<T>;
-    /**
-     * Returns class options polyfilled with some of
-     * the missing required options.
-     *
-     * Reference: [[totpOptions]]
-     */
-    allOptions(): Readonly<T>;
-    /**
-     * Reference: [[totpToken]]
-     */
-    generate(secret: SecretKey): string;
-    /**
-     * Reference: [[totpCheckWithWindow]]
-     */
-    checkDelta(token: string, secret: SecretKey): number | null;
-    /**
-     * Checks if a given TOTP token matches the generated
-     * token at the given epoch (default to current time).
-     *
-     * This method will return true as long as the token is
-     * still within the acceptable time window defined.
-     *
-     * i.e when [[checkDelta]] returns a number.
-     */
-    check(token: string, secret: SecretKey): boolean;
-    /**
-     * Same as [[check]] but accepts a single object based argument.
-     */
-    verify(opts: {
-        token: string;
-        secret: SecretKey;
-    }): boolean;
-    /**
-     * Reference: [[totpTimeRemaining]]
-     */
-    timeRemaining(): number;
-    /**
-     * Reference: [[totpTimeUsed]]
-     */
-    timeUsed(): number;
-    /**
-     * Reference: [[totpKeyuri]]
-     */
-    keyuri(accountName: string, issuer: string, secret: SecretKey): string;
-}