How to use the @algolia/client-common.encode function in @algolia/client-common

request(options: any = {}): Request {
      const headers: { readonly [key: string]: string } = {
        'X-Default-Header': 'Default value',
      };

      if (options.url !== undefined) {
        // eslint-disable-next-line no-param-reassign
        options.url +=
          (options.url.includes('?') ? '&' : '?') +
          encode('%s=%s', 'x-algolia-agent', `Algolia for JavaScript (${version}); Browser`);
      }

      return {
        data: '{}',
        headers,
        method: MethodEnum.Post,
        connectTimeout: 1,
        responseTimeout: 2,
        ...options,
      };
    },
  };

return (
    requestOptions?: ClearSynonymsOptions & RequestOptions
  ): Readonly> => {
    const { forwardToReplicas, ...options } = requestOptions || {};

    const mappedRequestOptions = createMappedRequestOptions(options);
    if (forwardToReplicas) {
      mappedRequestOptions.queryParameters.forwardToReplicas = 1; // eslint-disable-line functional/immutable-data
    }

    return createWaitablePromise(
      base.transporter.write(
        {
          method: MethodEnum.Post,
          path: encode('1/indexes/%s/synonyms/clear', base.indexName),
        },
        mappedRequestOptions
      ),
      (response, waitRequestOptions) => waitTask(base)(response.taskID, waitRequestOptions)
    );
  };
};

return (requestOptions?: RequestOptions): Readonly> => {
    const mappedRequestOptions = createMappedRequestOptions(requestOptions);

    // eslint-disable-next-line functional/immutable-data
    mappedRequestOptions.queryParameters.getVersion = '2';

    return base.transporter.read(
      {
        method: MethodEnum.Get,
        path: encode('1/indexes/%s/settings', base.indexName),
      },
      mappedRequestOptions
    );
  };
};

.map(key =>
      encode(
        '%s=%s',
        key,
        isObjectOrArray(parameters[key]) ? JSON.stringify(parameters[key]) : parameters[key]
      )
    )

);
        });
    };

    const wait: Wait = (_, waitRequestOptions) =>
      createRetryablePromise(retry => {
        return getApiKey(base)(apiKey, waitRequestOptions).then(getApiKeyResponse => {
          return hasChanged(getApiKeyResponse) ? Promise.resolve() : retry();
        });
      });

    return createWaitablePromise(
      base.transporter.write(
        {
          method: MethodEnum.Put,
          path: encode('1/keys/%s', apiKey),
          data,
        },
        options
      ),
      wait
    );
  };
};

return (
    query: string,
    requestOptions?: SearchSynonymsOptions & RequestOptions
  ): Readonly> => {
    return base.transporter.read(
      {
        method: MethodEnum.Post,
        path: encode('1/indexes/%s/synonyms/search', base.indexName),
        data: {
          query,
        },
      },
      requestOptions
    );
  };
};

return (requestOptions?: RequestOptions): Readonly> => {
    return createWaitablePromise(
      base.transporter.write(
        {
          method: MethodEnum.Delete,
          path: encode('1/indexes/%s', base.indexName),
        },
        requestOptions
      ),
      (response, waitRequestOptions) => waitTask(base)(response.taskID, waitRequestOptions)
    );
  };
};

return (requestOptions?: RequestOptions): Readonly> => {
    return createWaitablePromise(
      base.transporter.write(
        {
          method: MethodEnum.Post,
          path: encode('1/indexes/%s/clear', base.indexName),
        },
        requestOptions
      ),
      (response, waitRequestOptions) => waitTask(base)(response.taskID, waitRequestOptions)
    );
  };
};

return (
    query: string,
    requestOptions?: RequestOptions & SearchRulesOptions
  ): Readonly>> => {
    return base.transporter.read(
      {
        method: MethodEnum.Post,
        path: encode('1/indexes/%s/rules/search', base.indexName),
        data: {
          query,
        },
      },
      requestOptions
    );
  };
};

const operation = (
      from: string,
      to: string,
      type: string,
      operatioRequestOptions?: RequestOptions
    ): Readonly> => {
      return createWaitablePromise(
        base.transporter.write(
          {
            method: MethodEnum.Post,
            path: encode('1/indexes/%s/operation', from),
            data: {
              operation: type,
              destination: to,
            },
          },
          operatioRequestOptions
        ),
        (response, waitRequestOptions) => waitTask(base)(response.taskID, waitRequestOptions)
      );
    };