async def METHOD_NAME(self, resource_group_name: str, vault_name: str, **kwargs: Any) -> AsyncLROPoller[None]:
    """Triggers export of jobs and returns an OperationID to track.
    :param resource_group_name: The name of the resource group. The name is case insensitive.
     Required.
    :type resource_group_name: str
    :param vault_name: The name of the backup vault. Required.
    :type vault_name: str
    :keyword callable cls: A custom type or function that will be passed the direct response
    :keyword str continuation_token: A continuation token to restart a poller from a saved state.
    :keyword polling: By default, your polling method will be AsyncARMPolling. Pass in False for
     this operation to not poll, or pass in your own initialized polling object for a personal
     polling strategy.
    :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod
    :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
     Retry-After header is present.
    :return: An instance of AsyncLROPoller that returns either None or the result of cls(response)
    :rtype: ~azure.core.polling.AsyncLROPoller[None]
    :raises ~azure.core.exceptions.HttpResponseError:
    """
    _headers = kwargs.pop("headers", {}) or {}
    _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
    api_version: str = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version))
    cls: ClsType[None] = kwargs.pop("cls", None)
    polling: Union[bool, AsyncPollingMethod] = kwargs.pop("polling", True)
    lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
    cont_token: Optional[str] = kwargs.pop("continuation_token", None)
    if cont_token is None:
        raw_result = await self._trigger_initial(  # type: ignore
            resource_group_name=resource_group_name,
            vault_name=vault_name,
            api_version=api_version,
            cls=lambda x, y, z: x,
            headers=_headers,
            params=_params,
            **kwargs
        )
    kwargs.pop("error_map", None)
    def get_long_running_output(pipeline_response):  # pylint: disable=inconsistent-return-statements
        if cls:
            return cls(pipeline_response, None, {})
    if polling is True:
        polling_method: AsyncPollingMethod = cast(
            AsyncPollingMethod, AsyncARMPolling(lro_delay, lro_options={"final-state-via": "location"}, **kwargs)
        )
    elif polling is False:
        polling_method = cast(AsyncPollingMethod, AsyncNoPolling())
    else:
        polling_method = polling
    if cont_token:
        return AsyncLROPoller.from_continuation_token(
            polling_method=polling_method,
            continuation_token=cont_token,
            client=self._client,
            deserialization_callback=get_long_running_output,
        )
    return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method)  # type: ignore