async def METHOD_NAME(  # pylint: disable=inconsistent-return-statements
    self, resource_group_name: str, workspace_name: str, integration_runtime_name: str, **kwargs: Any
) -> None:
    """Sync integration runtime credentials.
    Force the integration runtime to synchronize credentials across integration runtime nodes, and
    this will override the credentials across all worker nodes with those available on the
    dispatcher node. If you already have the latest credential backup file, you should manually
    import it (preferred) on any self-hosted integration runtime node than using this API directly.
    :param resource_group_name: The name of the resource group. The name is case insensitive.
     Required.
    :type resource_group_name: str
    :param workspace_name: The name of the workspace. Required.
    :type workspace_name: str
    :param integration_runtime_name: Integration runtime name. Required.
    :type integration_runtime_name: str
    :keyword callable cls: A custom type or function that will be passed the direct response
    :return: None or the result of cls(response)
    :rtype: None
    :raises ~azure.core.exceptions.HttpResponseError:
    """
    error_map = {
        401: ClientAuthenticationError,
        404: ResourceNotFoundError,
        409: ResourceExistsError,
        304: ResourceNotModifiedError,
    }
    error_map.update(kwargs.pop("error_map", {}) or {})
    _headers = kwargs.pop("headers", {}) or {}
    _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
    api_version: Literal["2021-06-01-preview"] = kwargs.pop(
        "api_version", _params.pop("api-version", "2021-06-01-preview")
    )
    cls: ClsType[None] = kwargs.pop("cls", None)
    request = build_sync_request(
        resource_group_name=resource_group_name,
        workspace_name=workspace_name,
        integration_runtime_name=integration_runtime_name,
        subscription_id=self._config.subscription_id,
        api_version=api_version,
        template_url=self.METHOD_NAME.metadata["url"],
        headers=_headers,
        params=_params,
    )
    request = _convert_request(request)
    request.url = self._client.format_url(request.url)
    pipeline_response: PipelineResponse = await self._client._pipeline.run(  # pylint: disable=protected-access
        request, stream=False, **kwargs
    )
    response = pipeline_response.http_response
    if response.status_code not in [200]:
        map_error(status_code=response.status_code, response=response, error_map=error_map)
        error = self._deserialize.failsafe_deserialize(_models.ErrorResponse, pipeline_response)
        raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
    if cls:
        return cls(pipeline_response, None, {})