serialiseParamsBasedOnStyle = (context, param, paramValue, { isResponseSchema = false } = {}) => {
    const { style, explode, startValue, propSeparator, keyValueSeparator, isExplodable } =
      getParamSerialisationInfo(context, param, { isResponseSchema }),
      { enableOptionalParameters } = context.computedOptions;

    let serialisedValue = '',
      description = getParameterDescription(param),
      paramName = _.get(param, 'name'),
      disabled = !enableOptionalParameters && _.get(param, 'required') !== true,
      pmParams = [],
      isNotSerializable = false;

    // decide explodable params, starting value and separators between key-value and properties for serialisation
    // Ref: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.2.md#style-examples
    switch (style) {
      case 'form':
        if (explode && _.isObject(paramValue)) {
          const isArrayValue = _.isArray(paramValue);

          _.forEach(paramValue, (value, key) => {
            pmParams.push({
              key: isArrayValue ? paramName : key,
              value: (value === undefined ? '' : _.toString(value)),
              description,
              disabled
            });
          });

          return pmParams;
        }

        break;
      case 'deepObject':
        if (_.isObject(paramValue) && !_.isArray(paramValue)) {
          let extractedParams = extractDeepObjectParams(paramValue, paramName);

          _.forEach(extractedParams, (extractedParam) => {
            pmParams.push({
              key: extractedParam.key,
              value: _.toString(extractedParam.value) || '',
              description,
              disabled
            });
          });

          return pmParams;
        }
        else if (_.isArray(paramValue)) {
          isNotSerializable = true;
          pmParams.push({
            key: paramName,
            value: '<Error: Not supported in OAS>',
            disabled
          });
        }

        break;
      default:
        break;
    }

    if (isNotSerializable) {
      return pmParams;
    }

    if (_.isObject(paramValue)) {
      _.forEach(paramValue, (value, key) => {
        // add property separator for all index/keys except first
        !_.isEmpty(serialisedValue) && (serialisedValue += propSeparator);

        // append key for param that can be exploded
        isExplodable && (serialisedValue += (key + keyValueSeparator));
        serialisedValue += (value === undefined ? '' : _.toString(value));
      });
    }
    // for non-object and non-empty value append value as is to string
    else if (!_.isNil(paramValue)) {
      serialisedValue += paramValue;
    }

    // prepend starting value to serialised value (valid for empty value also)
    serialisedValue = startValue + serialisedValue;
    pmParams.push({
      key: paramName,
      value: _.toString(serialisedValue),
      description,
      disabled
    });

    return pmParams;
  }
Serialise Param based on mentioned style field in schema object

@param {Object} context - Global context object
@param {Object} param - OpenAPI Parameter object
@param {*} paramValue - Value of the parameter
@param {Object} options - Additional options for serialisation
@param {Boolean} options.isResponseSchema - Whether schema is from response or not
@returns {Array} - Array of key-value pairs for the parameter