/// <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);