How to use the @requestnetwork/types.RequestLogicTypes.ACTION_NAME function in @requestnetwork/types

request: RequestLogicTypes.IRequest | null,
  action: RequestLogicTypes.IAction,
  timestamp: number,
  advancedLogic?: AdvancedLogicTypes.IAdvancedLogic,
): RequestLogicTypes.IRequest {
  if (!Action.isActionVersionSupported(action)) {
    throw new Error('action version not supported');
  }

  // we don't want to modify the original request state
  const requestCopied: RequestLogicTypes.IRequest | null = request ? Utils.deepCopy(request) : null;

  let requestAfterApply: RequestLogicTypes.IRequest | null = null;

  // Creation request
  if (action.data.name === RequestLogicTypes.ACTION_NAME.CREATE) {
    if (requestCopied) {
      throw new Error('no request is expected at the creation');
    }
    requestAfterApply = CreateAction.createRequest(action, timestamp);
  } else {
    // Update request
    if (!requestCopied) {
      throw new Error('request is expected');
    }

    // Will throw if the request is not valid
    Request.checkRequest(requestCopied);

    if (action.data.name === RequestLogicTypes.ACTION_NAME.ACCEPT) {
      requestAfterApply = AcceptAction.applyActionToRequest(action, timestamp, requestCopied);
    }

function getRequestId(action: RequestLogicTypes.IAction): RequestLogicTypes.RequestId {
  // if a creation we need to compute the hash
  if (action.data.name === RequestLogicTypes.ACTION_NAME.CREATE) {
    return getActionHash(action);
  }
  return action.data.parameters.requestId;
}

requestAfterApply = IncreaseExpectedAmountAction.applyActionToRequest(
        action,
        timestamp,
        requestCopied,
      );
    }

    if (action.data.name === RequestLogicTypes.ACTION_NAME.REDUCE_EXPECTED_AMOUNT) {
      requestAfterApply = ReduceExpectedAmountAction.applyActionToRequest(
        action,
        timestamp,
        requestCopied,
      );
    }

    if (action.data.name === RequestLogicTypes.ACTION_NAME.ADD_EXTENSIONS_DATA) {
      requestAfterApply = AddExtensionsData.applyActionToRequest(action, timestamp, requestCopied);
    }
  }

  if (!requestAfterApply) {
    throw new Error(`Unknown action ${action.data.name}`);
  }

  // skip extension application if no extension given or no advanced logic layer given
  if (action.data.parameters.extensionsData && advancedLogic) {
    // Apply the extension on the state
    requestAfterApply.extensions = action.data.parameters.extensionsData.reduce(
      (extensionState: RequestLogicTypes.IExtensionStates, extensionAction: any) => {
        return advancedLogic.applyActionToExtensions(
          extensionState,
          extensionAction,

function format(
  reduceAmountParameters: RequestLogicTypes.IReduceExpectedAmountParameters,
  signerIdentity: IdentityTypes.IIdentity,
  signatureProvider: SignatureProviderTypes.ISignatureProvider,
): Promise {
  if (!Utils.amount.isValid(reduceAmountParameters.deltaAmount)) {
    throw new Error('deltaAmount must be a string representing a positive integer');
  }

  const unsignedAction: RequestLogicTypes.IUnsignedAction = {
    name: RequestLogicTypes.ACTION_NAME.REDUCE_EXPECTED_AMOUNT,
    parameters: reduceAmountParameters,
    version: Version.currentVersion,
  };

  return Action.createAction(unsignedAction, signerIdentity, signatureProvider);
}

function generateEvent(
  action: RequestLogicTypes.IAction,
  timestamp: number,
  actionSigner: IdentityTypes.IIdentity,
): RequestLogicTypes.IEvent {
  const params = action.data.parameters;

  const event: RequestLogicTypes.IEvent = {
    actionSigner,
    name: RequestLogicTypes.ACTION_NAME.INCREASE_EXPECTED_AMOUNT,
    parameters: {
      deltaAmount: action.data.parameters.deltaAmount,
      extensionsDataLength: params.extensionsData ? params.extensionsData.length : 0,
    },
    timestamp,
  };
  return event;
}

function generateEvent(
  action: RequestLogicTypes.IAction,
  timestamp: number,
  actionSigner: IdentityTypes.IIdentity,
): RequestLogicTypes.IEvent {
  const params = action.data.parameters;

  const event: RequestLogicTypes.IEvent = {
    actionSigner,
    name: RequestLogicTypes.ACTION_NAME.ADD_EXTENSIONS_DATA,
    parameters: {
      extensionsDataLength: params.extensionsData ? params.extensionsData.length : 0,
    },
    timestamp,
  };
  return event;
}

function generateEvent(
  action: RequestLogicTypes.IAction,
  timestamp: number,
  actionSigner: IdentityTypes.IIdentity,
): RequestLogicTypes.IEvent {
  const params = action.data.parameters;

  const event: RequestLogicTypes.IEvent = {
    actionSigner,
    name: RequestLogicTypes.ACTION_NAME.ACCEPT,
    parameters: {
      extensionsDataLength: params.extensionsData ? params.extensionsData.length : 0,
    },
    timestamp,
  };
  return event;
}

function format(
  cancelParameters: RequestLogicTypes.ICancelParameters,
  signerIdentity: IdentityTypes.IIdentity,
  signatureProvider: SignatureProviderTypes.ISignatureProvider,
): Promise {
  const unsignedAction: RequestLogicTypes.IUnsignedAction = {
    name: RequestLogicTypes.ACTION_NAME.CANCEL,
    parameters: cancelParameters,
    version: Version.currentVersion,
  };

  return Action.createAction(unsignedAction, signerIdentity, signatureProvider);
}

function generateEvent(
  action: RequestLogicTypes.IAction,
  timestamp: number,
  actionSigner: IdentityTypes.IIdentity,
): RequestLogicTypes.IEvent {
  const params = action.data.parameters;

  const event: RequestLogicTypes.IEvent = {
    actionSigner,
    name: RequestLogicTypes.ACTION_NAME.CREATE,
    parameters: {
      expectedAmount: params.expectedAmount,
      extensionsDataLength: params.extensionsData ? params.extensionsData.length : 0,
      isSignedRequest: false,
    },
    timestamp,
  };
  return event;
}