How to use the @azure/event-hubs.delay function in @azure/event-hubs

const client = new EventHubClient(connectionString, eventHubName);
  const partitionIds = await client.getPartitionIds();
  const consumer = client.createConsumer("$Default", partitionIds[0], EventPosition.earliest());

  const onMessageHandler: OnMessage = (brokeredMessage: EventData) => {
    console.log(`Received event: ${brokeredMessage.body}`);
  };
  const onErrorHandler: OnError = (err: MessagingError | Error) => {
    console.log("Error occurred: ", err);
  };

  try {
    const rcvHandler = consumer.receive(onMessageHandler, onErrorHandler);

    // Waiting long enough before closing the consumer to receive event
    await delay(5000);
    await rcvHandler.stop();
  } finally {
    await client.close();
  }
}

console.log(`Received event: ${message.body}`);
    }
  };

  const subscription = client.subscribe(consumerGroupName, onReceivedEventsHandler,
    // for simplicity we'll just target a single partition for our demo
    partitionIds[0], {
    onError: async (err: Error, partitionContext: PartitionContext) => {
      console.log(`Error occurred in the subscription for ${partitionContext.partitionId}: ${err}`);
    },
    // if this subscription happens tob e the first
    defaultEventPosition: EventPosition.earliest()
  });

  // Waiting long enough before closing the consumer to receive event
  await delay(5000);
  await subscription.close();
  await client.close();
}

consumerGroup,
            enableReceiverRuntimeMetric: true,
            eventPosition: EventPosition.fromEnqueuedTime(startTime),
            name: `${hubInfo.path}_${partitionId}`,
        };
        let receiver: ReceiveHandler;
        try {
            receiver = eventHubClient.receive(
                partitionId,
                onMessage,
                (err: object) => {
                    console.log(err); // tslint:disable-line: no-console
                },
                receiveOptions);
            receivers.push(receiver);
            await delay(SERVER_WAIT).then(() => {
                receiver.stop().catch(err => {
                    console.log(`couldn't stop receiver on partition[${partitionId}]: ${err}`); // tslint:disable-line: no-console
                });
            });
        }
        catch (ex) {
            if (receiver) {
                receiver.stop().catch(err => {
                    console.log(`failed to stop receiver: ${err}`); // tslint:disable-line: no-console
                });
            }
            console.log(`receiver fail: ${ex}`); // tslint:disable-line: no-console
        }
    });
    await delay(SERVER_WAIT).then(() => {

};
      if (cache[messageId]) {
        log("Looks like message with id '%s' is already present in the cache %o", messageId, cache);
      }
      cache[messageId] = m;
      try {
        const delivery = await client2.send(m, partitionId);
        log("Sent message with id '%s'. Delivery id '%d', tag '%s'.",
          messageId, delivery.id, delivery.tag.toString());
      } catch (err) {
        log("An error occurred while sending the message with id '%s', %o", messageId, err);
      }
      log("Sleeping for %d seconds. Next message will be sent around %s",
        waitTime / 1000, new Date(nextIterationAt).toString());
      try {
        await delay(waitTime);
      } catch (err) {
        log("An error occurred while sleeping for %d milliseconds, %o", waitTime, err);
      }
    }
  } catch (err) {
    return Promise.reject(err);
  }
}

const num = m.sequenceNumber;
      if (mid && !cache[mid]) {
        const msg = `Error message with seq num ${num} and id '${mid}' not found in cache..`;
        log(">>>> %o", new Error(msg));
      } else {
        log("Received message with seq num %d and id '%s' and it is present in cache.", num, mid);
        delete cache[mid];
      }
    };
    const onError = (err: any) => {
      log("^^^^^^^^^^ An error occured with the receiver: %o", err);
    };
    const now = Date.now();
    client1.receive(partitionId, onMessage, onError, { consumerGroup: consumerGroup, eventPosition: EventPosition.fromEnqueuedTime(now) });
    log("Started receiving messages from enqueued time : '%s'.", new Date(now).toString());
    await delay(3000);
    while (true) {
      const waitTime = randomNumberFromInterval(minWaitTime, maxWaitTime) * 1000;
      const nextIterationAt = Date.now() + waitTime;
      const messageId = uuid();
      const m: EventData = {
        body: "Hello World Event Hub " + new Date().toString(),
        properties: {
          message_id: messageId
        }
      };
      if (cache[messageId]) {
        log("Looks like message with id '%s' is already present in the cache %o", messageId, cache);
      }
      cache[messageId] = m;
      try {
        const delivery = await client2.send(m, partitionId);

if (partitionId) {
              log("[Client-%d] [iteration-%d] [partition-%d] message number %d not successful.", index, i, partitionId, j + 1);
            } else {
              log("[Client-%d] [iteration-%d] message number %d not successful.", index, i, j + 1);
            }
          }
        }

        const totalTime = (Date.now() - startTime) / 1000;
        const totalMsgs = msgCount * msgGroup;
        log("[Client-%d] [iteration-%d] total time in seconds: %d, number of messages sent: %d, messages sent/second: %d, size (in bytes) of each message: %d.", index, i,
          totalTime, totalMsgs, totalMsgs / totalTime, msgGroup * msgBody.length);
        if (wait > 0) {
          if (i + 1 < iterationValue) {
            log("[Client-%d] #################### Waiting for %d seconds, before starting iteration: %d ########################", index, wait, i + 1);
            await delay(wait * 1000);
          } else {
            log("[Client-%d] #################### All iterations complete ########################", index);
          }
        }
      }
    } catch (err) {
      log(err);
    }
  }
  if (partitionIds.length) {

log.partitionManager(withHost("Starting the first scan."));
      }
      const didSteal = await this._partitionScanner.scan(isFirst);
      log.partitionManager(withHost("Did we steal any leases in this scan: %s."), didSteal);
      let seconds: number = didSteal
        ? this._context.fastScanInterval!
        : this._context.slowScanInterval!;
      if (isFirst) {
        seconds = this._context.startupScanDelay!;
        isFirst = false;
      }
      log.partitionManager(
        withHost("Sleeping for %d seconds before starting the next scan."),
        seconds
      );
      await delay(seconds * 1000);
    }
  }
}