How to use the cucumber-expressions.ParameterTypeRegistry function in cucumber-expressions

const glob = require('glob');
const path = require('path');
const {CucumberExpression, ParameterTypeRegistry} = require('cucumber-expressions');

const {steps} = require('./args').argv;
const stepDefinitionsPaths = [].concat(...steps.map(pattern => glob.sync(pattern)));
const parameterTypeRegistry = new ParameterTypeRegistry();

//
// A global registry to load load and resolve all step definitions
//
class StepDefinitionRegistry {
	constructor() {
		this.definitions = {};
		this.runtime = {};
		this.latestType = '';

		['given', 'when', 'then'].forEach(keyword => {
			this.definitions[keyword] = [];
			this.runtime[keyword] = (expression, implementation) => this.definitions[keyword].push({
				implementation,
				expression: new CucumberExpression(expression, parameterTypeRegistry)
			});

let steps = {};

const STACK_POSITION = 2;

/**
 * @param {*} step
 * @param {*} fn
 */
const addStep = (step, fn) => {
  const stack = (new Error()).stack;
  steps[step] = fn;
  fn.line = stack && stack.split('\n')[STACK_POSITION];
  if (fn.line) fn.line = fn.line.trim().replace(/^at (.*?)\(/, '(');
};

const parameterTypeRegistry = new ParameterTypeRegistry();

const matchStep = (step) => {
  for (const stepName in steps) {
    if (stepName.indexOf('/') === 0) {
      const res = step.match(new RegExp(stepName.slice(1, -1)));
      if (res) {
        const fn = steps[stepName];
        fn.params = res.slice(1);
        return fn;
      }
      continue;
    }
    const expression = new CucumberExpression(stepName, parameterTypeRegistry);
    const res = expression.match(step);
    if (res) {
      const fn = steps[stepName];

function build() {
  return new ParameterTypeRegistry()
}

reset(cwd: string, newId: IdGenerator.NewId): void {
    this.cwd = cwd
    this.newId = newId
    this.afterTestCaseHookDefinitionConfigs = []
    this.afterTestRunHookDefinitionConfigs = []
    this.beforeTestCaseHookDefinitionConfigs = []
    this.beforeTestRunHookDefinitionConfigs = []
    this.definitionFunctionWrapper = null
    this.defaultTimeout = 5000
    this.parameterTypeRegistry = new ParameterTypeRegistry()
    this.stepDefinitionConfigs = []
    this.World = World
  }
}

throw new Error('Nope')
      }
    ),
    new StepDefinition(
      new CucumberExpression('a pending {word}', new ParameterTypeRegistry()),
      () => 'pending'
    ),
    new StepDefinition(
      new CucumberExpression(
        'an ambiguous {word}',
        new ParameterTypeRegistry()
      ),
      () => undefined
    ),
    new StepDefinition(
      new CucumberExpression('an {word} step', new ParameterTypeRegistry()),
      () => undefined
    ),
    new StepDefinition(
      new CucumberExpression(
        'I have {int} cukes in my belly',
        new ParameterTypeRegistry()
      ),
      cukes => cukes
    ),
  ])
}

constructor() {
    this.definitions = {};
    this.runtime = {};
    this.options = {
      parameterTypeRegistry: new ParameterTypeRegistry()
    };

    this.definitions = [];
    this.runtime = (matcher, implementation) => {
      let expression;
      if (matcher instanceof RegExp) {
        expression = new RegularExpression(
          matcher,
          this.options.parameterTypeRegistry
        );
      } else {
        expression = new CucumberExpression(
          matcher,
          this.options.parameterTypeRegistry
        );
      }