/// <summary>
/// Deletes an index.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task DeleteIndexAsync(
DeleteIndexRequest request,
CallSettings callSettings = null)
{
Modify_DeleteIndexRequest(ref request, ref callSettings);
return(_callDeleteIndex.Async(request, callSettings));
}
/// <summary>
/// Gets an index.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <Index> GetIndexAsync(
GetIndexRequest request,
CallSettings callSettings = null)
{
Modify_GetIndexRequest(ref request, ref callSettings);
return(_callGetIndex.Async(request, callSettings));
}
/// <summary>
/// Creates the specified index.
/// A newly created index's initial state is `CREATING`. On completion of the
/// returned [google.longrunning.Operation][google.longrunning.Operation], the state will be `READY`.
/// If the index already exists, the call will return an `ALREADY_EXISTS`
/// status.
///
/// During creation, the process could result in an error, in which case the
/// index will move to the `ERROR` state. The process can be recovered by
/// fixing the data that caused the error, removing the index with
/// [delete][google.firestore.admin.v1beta1.FirestoreAdmin.DeleteIndex], then re-creating the index with
/// [create][google.firestore.admin.v1beta1.FirestoreAdmin.CreateIndex].
///
/// Indexes with a single field cannot be created.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <Operation> CreateIndexAsync(
CreateIndexRequest request,
CallSettings callSettings = null)
{
Modify_CreateIndexRequest(ref request, ref callSettings);
return(_callCreateIndex.Async(request, callSettings));
}
/// <summary>
/// Modifies a row atomically. The method reads the latest existing timestamp
/// and value from the specified columns and writes a new entry based on
/// pre-defined read/modify/write rules. The new value for the timestamp is the
/// greater of the existing timestamp or the current server time. The method
/// returns the new contents of all modified cells.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <ReadModifyWriteRowResponse> ReadModifyWriteRowAsync(
ReadModifyWriteRowRequest request,
CallSettings callSettings = null)
{
Modify_ReadModifyWriteRowRequest(ref request, ref callSettings);
return(_callReadModifyWriteRow.Async(request, callSettings));
}
/// <summary>
/// Deletes all error events of a given project.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <DeleteEventsResponse> DeleteEventsAsync(
DeleteEventsRequest request,
CallSettings callSettings = null)
{
Modify_DeleteEventsRequest(ref request, ref callSettings);
return(_callDeleteEvents.Async(request, callSettings));
}
/// <summary>
/// Mutates a row atomically. Cells already present in the row are left
/// unchanged unless explicitly changed by `mutation`.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <MutateRowResponse> MutateRowAsync(
MutateRowRequest request,
CallSettings callSettings = null)
{
Modify_MutateRowRequest(ref request, ref callSettings);
return(_callMutateRow.Async(request, callSettings));
}
/// <summary>
/// Run image detection and annotation for a batch of images.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <BatchAnnotateImagesResponse> BatchAnnotateImagesAsync(
BatchAnnotateImagesRequest request,
CallSettings callSettings = null)
{
Modify_BatchAnnotateImagesRequest(ref request, ref callSettings);
return(_callBatchAnnotateImages.Async(request, callSettings));
}
/// <summary>
/// A convenience method that provides all the features that analyzeSentiment,
/// analyzeEntities, and analyzeSyntax provide in one call.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <AnnotateTextResponse> AnnotateTextAsync(
AnnotateTextRequest request,
CallSettings callSettings = null)
{
Modify_AnnotateTextRequest(ref request, ref callSettings);
return(_callAnnotateText.Async(request, callSettings));
}
/// <summary>
/// Sends new traces to Stackdriver Trace or updates existing traces. If the ID
/// of a trace that you send matches that of an existing trace, any fields
/// in the existing trace and its spans are overwritten by the provided values,
/// and any new fields provided are merged with the existing trace data. If the
/// ID does not match, a new trace is created.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task PatchTracesAsync(
PatchTracesRequest request,
CallSettings callSettings = null)
{
Modify_PatchTracesRequest(ref request, ref callSettings);
return(_callPatchTraces.Async(request, callSettings));
}
/// <summary>
/// Sends new spans to new or existing traces. You cannot update
/// existing spans.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task BatchWriteSpansAsync(
BatchWriteSpansRequest request,
CallSettings callSettings = null)
{
Modify_BatchWriteSpansRequest(ref request, ref callSettings);
return(_callBatchWriteSpans.Async(request, callSettings));
}
/// <summary>
/// Report an individual error event.
///
/// This endpoint accepts <strong>either</strong> an OAuth token,
/// <strong>or</strong> an
/// <a href="https://support.google.com/cloud/answer/6158862">API key</a>
/// for authentication. To use an API key, append it to the URL as the value of
/// a `key` parameter. For example:
/// <pre>POST https://clouderrorreporting.googleapis.com/v1beta1/projects/example-project/events:report?key=123ABC456</pre>
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <ReportErrorEventResponse> ReportErrorEventAsync(
ReportErrorEventRequest request,
CallSettings callSettings = null)
{
Modify_ReportErrorEventRequest(ref request, ref callSettings);
return(_callReportErrorEvent.Async(request, callSettings));
}
/// <summary>
/// Creates a new span.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <Span> CreateSpanAsync(
Span request,
CallSettings callSettings = null)
{
Modify_Span(ref request, ref callSettings);
return(_callCreateSpan.Async(request, callSettings));
}
/// <summary>
/// Mutates a row atomically based on the output of a predicate Reader filter.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <CheckAndMutateRowResponse> CheckAndMutateRowAsync(
CheckAndMutateRowRequest request,
CallSettings callSettings = null)
{
Modify_CheckAndMutateRowRequest(ref request, ref callSettings);
return(_callCheckAndMutateRow.Async(request, callSettings));
}
/// <summary>
/// Perform synchronous speech-recognition: receive results after all audio
/// has been sent and processed.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <SyncRecognizeResponse> SyncRecognizeAsync(
SyncRecognizeRequest request,
CallSettings callSettings = null)
{
Modify_SyncRecognizeRequest(ref request, ref callSettings);
return(_callSyncRecognize.Async(request, callSettings));
}
/// <summary>
/// Updates the breakpoint state or mutable fields.
/// The entire Breakpoint message must be sent back to the controller service.
///
/// Updates to active breakpoint fields are only allowed if the new value
/// does not change the breakpoint specification. Updates to the `location`,
/// `condition` and `expressions` fields should not alter the breakpoint
/// semantics. These may only make changes such as canonicalizing a value
/// or snapping the location to the correct line of code.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <UpdateActiveBreakpointResponse> UpdateActiveBreakpointAsync(
UpdateActiveBreakpointRequest request,
CallSettings callSettings = null)
{
Modify_UpdateActiveBreakpointRequest(ref request, ref callSettings);
return(_callUpdateActiveBreakpoint.Async(request, callSettings));
}
/// <summary>
/// Returns the list of all active breakpoints for the debuggee.
///
/// The breakpoint specification (`location`, `condition`, and `expressions`
/// fields) is semantically immutable, although the field values may
/// change. For example, an agent may update the location line number
/// to reflect the actual line where the breakpoint was set, but this
/// doesn't change the breakpoint semantics.
///
/// This means that an agent does not need to check if a breakpoint has changed
/// when it encounters the same breakpoint on a successive call.
/// Moreover, an agent should remember the breakpoints that are completed
/// until the controller removes them from the active list to avoid
/// setting those breakpoints again.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <ListActiveBreakpointsResponse> ListActiveBreakpointsAsync(
ListActiveBreakpointsRequest request,
CallSettings callSettings = null)
{
Modify_ListActiveBreakpointsRequest(ref request, ref callSettings);
return(_callListActiveBreakpoints.Async(request, callSettings));
}
/// <summary>
/// Registers the debuggee with the controller service.
///
/// All agents attached to the same application must call this method with
/// exactly the same request content to get back the same stable `debuggee_id`.
/// Agents should call this method again whenever `google.rpc.Code.NOT_FOUND`
/// is returned from any controller method.
///
/// This protocol allows the controller service to disable debuggees, recover
/// from data loss, or change the `debuggee_id` format. Agents must handle
/// `debuggee_id` value changing upon re-registration.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <RegisterDebuggeeResponse> RegisterDebuggeeAsync(
RegisterDebuggeeRequest request,
CallSettings callSettings = null)
{
Modify_RegisterDebuggeeRequest(ref request, ref callSettings);
return(_callRegisterDebuggee.Async(request, callSettings));
}
/// <summary>
/// Replace the data for the specified group.
/// Fails if the group does not exist.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <ErrorGroup> UpdateGroupAsync(
UpdateGroupRequest request,
CallSettings callSettings = null)
{
Modify_UpdateGroupRequest(ref request, ref callSettings);
return(_callUpdateGroup.Async(request, callSettings));
}
/// <summary>
/// Gets a single trace by its ID.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <Trace> GetTraceAsync(
GetTraceRequest request,
CallSettings callSettings = null)
{
Modify_GetTraceRequest(ref request, ref callSettings);
return(_callGetTrace.Async(request, callSettings));
}
/// <summary>
/// Analyzes the syntax of the text and provides sentence boundaries and
/// tokenization along with part of speech tags, dependency trees, and other
/// properties.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override Task <AnalyzeSyntaxResponse> AnalyzeSyntaxAsync(
AnalyzeSyntaxRequest request,
CallSettings callSettings = null)
{
Modify_AnalyzeSyntaxRequest(ref request, ref callSettings);
return(_callAnalyzeSyntax.Async(request, callSettings));
}
/// <summary>
/// Run async image detection and annotation for a list of generic files (e.g.
/// PDF) which may contain multiple pages and multiple images per page.
/// Progress and results can be retrieved through the
/// `google.longrunning.Operations` interface.
/// `Operation.metadata` contains `OperationMetadata` (metadata).
/// `Operation.response` contains `AsyncBatchAnnotateFilesResponse` (results).
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override async Task <Operation <AsyncBatchAnnotateFilesResponse, OperationMetadata> > AsyncBatchAnnotateFilesAsync(
AsyncBatchAnnotateFilesRequest request,
CallSettings callSettings = null)
{
Modify_AsyncBatchAnnotateFilesRequest(ref request, ref callSettings);
return(new Operation <AsyncBatchAnnotateFilesResponse, OperationMetadata>(
await _callAsyncBatchAnnotateFiles.Async(request, callSettings).ConfigureAwait(false), AsyncBatchAnnotateFilesOperationsClient));
}
/// <summary>
/// Analyzes the sentiment of the provided text.
/// </summary>
/// <param name="document">
/// Input document. Currently, `analyzeSentiment` only supports English text
/// ([Document.language][google.cloud.language.v1beta1.Document.language]="EN").
/// </param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override Task <AnalyzeSentimentResponse> AnalyzeSentimentAsync(
Document document,
CallSettings callSettings = null) => _callAnalyzeSentiment.Async(
new AnalyzeSentimentRequest
{
Document = document,
},
callSettings);
/// <summary>
/// Performs asynchronous video annotation. Progress and results can be
/// retrieved through the `google.longrunning.Operations` interface.
/// `Operation.metadata` contains `AnnotateVideoProgress` (progress).
/// `Operation.response` contains `AnnotateVideoResponse` (results).
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override async Task <Operation <AnnotateVideoResponse, AnnotateVideoProgress> > AnnotateVideoAsync(
AnnotateVideoRequest request,
CallSettings callSettings = null)
{
Modify_AnnotateVideoRequest(ref request, ref callSettings);
return(new Operation <AnnotateVideoResponse, AnnotateVideoProgress>(
await _callAnnotateVideo.Async(request, callSettings).ConfigureAwait(false), AnnotateVideoOperationsClient));
}
/// <summary>
/// Deletes a logs-based metric.
/// </summary>
/// <param name="metricName">
/// The resource name of the metric to delete.
/// Example: `"projects/my-project-id/metrics/my-metric-id"`.
/// </param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override Task DeleteLogMetricAsync(
string metricName,
CallSettings callSettings = null) => _callDeleteLogMetric.Async(
new DeleteLogMetricRequest
{
MetricName = metricName,
},
callSettings);
/// <summary>
/// Creates the given topic with the given name.
/// </summary>
/// <param name="name">
/// The name of the topic. It must have the format
/// `"projects/{project}/topics/{topic}"`. `{topic}` must start with a letter,
/// and contain only letters (`[A-Za-z]`), numbers (`[0-9]`), dashes (`-`),
/// underscores (`_`), periods (`.`), tildes (`~`), plus (`+`) or percent
/// signs (`%`). It must be between 3 and 255 characters in length, and it
/// must not start with `"goog"`.
/// </param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override Task <Topic> CreateTopicAsync(
string name,
CallSettings callSettings = null) => _callCreateTopic.Async(
new Topic
{
Name = name,
},
callSettings);
/// <summary>
/// Perform asynchronous speech-recognition: receive results via the
/// google.longrunning.Operations interface. Returns either an
/// `Operation.error` or an `Operation.response` which contains
/// an `AsyncRecognizeResponse` message.
/// </summary>
/// <param name="request">
/// The request object containing all of the parameters for the API call.
/// </param>
/// <param name="callSettings">
/// If not null, applies overrides to this RPC call.
/// </param>
/// <returns>
/// A Task containing the RPC response.
/// </returns>
public override async Task <Operation <AsyncRecognizeResponse> > AsyncRecognizeAsync(
AsyncRecognizeRequest request,
CallSettings callSettings = null)
{
Modify_AsyncRecognizeRequest(ref request, ref callSettings);
return(new Operation <AsyncRecognizeResponse>(
await _callAsyncRecognize.Async(request, callSettings), LongRunningOperationsClient));
}
/// <summary>
/// Gets the configuration of a topic.
/// </summary>
/// <param name="topic">The name of the topic to get.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override Task <Topic> GetTopicAsync(
string topic,
CallSettings callSettings = null) => _callGetTopic.Async(
new GetTopicRequest
{
Topic = topic,
},
callSettings);
/// <summary>
/// Deletes the topic with the given name. Generates `NOT_FOUND` if the topic
/// does not exist. After a topic is deleted, a new topic may be created with
/// the same name; this is an entirely new topic with none of the old
/// configuration or subscriptions. Existing subscriptions to this topic are
/// not deleted, but their `topic` field is set to `_deleted-topic_`.
/// </summary>
/// <param name="topic">Name of the topic to delete.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override Task DeleteTopicAsync(
string topic,
CallSettings callSettings = null) => _callDeleteTopic.Async(
new DeleteTopicRequest
{
Topic = topic,
},
callSettings);
/// <summary>
/// Gets a logs-based metric.
/// </summary>
/// <param name="metricName">
/// The resource name of the desired metric.
/// Example: `"projects/my-project-id/metrics/my-metric-id"`.
/// </param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override Task <LogMetric> GetLogMetricAsync(
string metricName,
CallSettings callSettings = null) => _callGetLogMetric.Async(
new GetLogMetricRequest
{
MetricName = metricName,
},
callSettings);
/// <summary>
/// Gets a sink.
/// </summary>
/// <param name="sinkName">
/// The resource name of the sink to return.
/// Example: `"projects/my-project-id/sinks/my-sink-id"`.
/// </param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override Task <LogSink> GetSinkAsync(
string sinkName,
CallSettings callSettings = null) => _callGetSink.Async(
new GetSinkRequest
{
SinkName = sinkName,
},
callSettings);
