pulumi/sdk/dotnet/Pulumirpc/ProviderGrpc.cs

// <auto-generated>
//     Generated by the protocol buffer compiler.  DO NOT EDIT!
//     source: provider.proto
// </auto-generated>
// Original file comments:
// Copyright 2016-2017, Pulumi Corporation.  All rights reserved.
//
#pragma warning disable 1591
#region Designer generated code

using System;
using System.Threading;
using System.Threading.Tasks;
using grpc = global::Grpc.Core;

namespace Pulumirpc {
  /// <summary>
  /// ResourceProvider is a service that understands how to create, read, update, or delete resources for types defined
  /// within a single package.  It is driven by the overall planning engine in response to resource diffs.
  /// </summary>
  public static partial class ResourceProvider
  {
    static readonly string __ServiceName = "pulumirpc.ResourceProvider";

    static readonly grpc::Marshaller<global::Pulumirpc.ConfigureRequest> __Marshaller_ConfigureRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.ConfigureRequest.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Google.Protobuf.WellKnownTypes.Empty> __Marshaller_Empty = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Google.Protobuf.WellKnownTypes.Empty.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.InvokeRequest> __Marshaller_InvokeRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.InvokeRequest.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.InvokeResponse> __Marshaller_InvokeResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.InvokeResponse.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.CheckRequest> __Marshaller_CheckRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.CheckRequest.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.CheckResponse> __Marshaller_CheckResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.CheckResponse.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.DiffRequest> __Marshaller_DiffRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.DiffRequest.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.DiffResponse> __Marshaller_DiffResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.DiffResponse.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.CreateRequest> __Marshaller_CreateRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.CreateRequest.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.CreateResponse> __Marshaller_CreateResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.CreateResponse.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.UpdateRequest> __Marshaller_UpdateRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.UpdateRequest.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.UpdateResponse> __Marshaller_UpdateResponse = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.UpdateResponse.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.DeleteRequest> __Marshaller_DeleteRequest = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.DeleteRequest.Parser.ParseFrom);
    static readonly grpc::Marshaller<global::Pulumirpc.PluginInfo> __Marshaller_PluginInfo = grpc::Marshallers.Create((arg) => global::Google.Protobuf.MessageExtensions.ToByteArray(arg), global::Pulumirpc.PluginInfo.Parser.ParseFrom);

    static readonly grpc::Method<global::Pulumirpc.ConfigureRequest, global::Google.Protobuf.WellKnownTypes.Empty> __Method_Configure = new grpc::Method<global::Pulumirpc.ConfigureRequest, global::Google.Protobuf.WellKnownTypes.Empty>(
        grpc::MethodType.Unary,
        __ServiceName,
        "Configure",
        __Marshaller_ConfigureRequest,
        __Marshaller_Empty);

    static readonly grpc::Method<global::Pulumirpc.InvokeRequest, global::Pulumirpc.InvokeResponse> __Method_Invoke = new grpc::Method<global::Pulumirpc.InvokeRequest, global::Pulumirpc.InvokeResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "Invoke",
        __Marshaller_InvokeRequest,
        __Marshaller_InvokeResponse);

    static readonly grpc::Method<global::Pulumirpc.CheckRequest, global::Pulumirpc.CheckResponse> __Method_Check = new grpc::Method<global::Pulumirpc.CheckRequest, global::Pulumirpc.CheckResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "Check",
        __Marshaller_CheckRequest,
        __Marshaller_CheckResponse);

    static readonly grpc::Method<global::Pulumirpc.DiffRequest, global::Pulumirpc.DiffResponse> __Method_Diff = new grpc::Method<global::Pulumirpc.DiffRequest, global::Pulumirpc.DiffResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "Diff",
        __Marshaller_DiffRequest,
        __Marshaller_DiffResponse);

    static readonly grpc::Method<global::Pulumirpc.CreateRequest, global::Pulumirpc.CreateResponse> __Method_Create = new grpc::Method<global::Pulumirpc.CreateRequest, global::Pulumirpc.CreateResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "Create",
        __Marshaller_CreateRequest,
        __Marshaller_CreateResponse);

    static readonly grpc::Method<global::Pulumirpc.UpdateRequest, global::Pulumirpc.UpdateResponse> __Method_Update = new grpc::Method<global::Pulumirpc.UpdateRequest, global::Pulumirpc.UpdateResponse>(
        grpc::MethodType.Unary,
        __ServiceName,
        "Update",
        __Marshaller_UpdateRequest,
        __Marshaller_UpdateResponse);

    static readonly grpc::Method<global::Pulumirpc.DeleteRequest, global::Google.Protobuf.WellKnownTypes.Empty> __Method_Delete = new grpc::Method<global::Pulumirpc.DeleteRequest, global::Google.Protobuf.WellKnownTypes.Empty>(
        grpc::MethodType.Unary,
        __ServiceName,
        "Delete",
        __Marshaller_DeleteRequest,
        __Marshaller_Empty);

    static readonly grpc::Method<global::Google.Protobuf.WellKnownTypes.Empty, global::Pulumirpc.PluginInfo> __Method_GetPluginInfo = new grpc::Method<global::Google.Protobuf.WellKnownTypes.Empty, global::Pulumirpc.PluginInfo>(
        grpc::MethodType.Unary,
        __ServiceName,
        "GetPluginInfo",
        __Marshaller_Empty,
        __Marshaller_PluginInfo);

    /// <summary>Service descriptor</summary>
    public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor
    {
      get { return global::Pulumirpc.ProviderReflection.Descriptor.Services[0]; }
    }

    /// <summary>Base class for server-side implementations of ResourceProvider</summary>
    public abstract partial class ResourceProviderBase
    {
      /// <summary>
      /// Configure configures the resource provider with "globals" that control its behavior.
      /// </summary>
      /// <param name="request">The request received from the client.</param>
      /// <param name="context">The context of the server-side call handler being invoked.</param>
      /// <returns>The response to send back to the client (wrapped by a task).</returns>
      public virtual global::System.Threading.Tasks.Task<global::Google.Protobuf.WellKnownTypes.Empty> Configure(global::Pulumirpc.ConfigureRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Invoke dynamically executes a built-in function in the provider.
      /// </summary>
      /// <param name="request">The request received from the client.</param>
      /// <param name="context">The context of the server-side call handler being invoked.</param>
      /// <returns>The response to send back to the client (wrapped by a task).</returns>
      public virtual global::System.Threading.Tasks.Task<global::Pulumirpc.InvokeResponse> Invoke(global::Pulumirpc.InvokeRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Check validates that the given property bag is valid for a resource of the given type and returns the inputs
      /// that should be passed to successive calls to Diff, Create, or Update for this resource. As a rule, the provider
      /// inputs returned by a call to Check should preserve the original representation of the properties as present in
      /// the program inputs. Though this rule is not required for correctness, violations thereof can negatively impact
      /// the end-user experience, as the provider inputs are using for detecting and rendering diffs.
      /// </summary>
      /// <param name="request">The request received from the client.</param>
      /// <param name="context">The context of the server-side call handler being invoked.</param>
      /// <returns>The response to send back to the client (wrapped by a task).</returns>
      public virtual global::System.Threading.Tasks.Task<global::Pulumirpc.CheckResponse> Check(global::Pulumirpc.CheckRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Diff checks what impacts a hypothetical update will have on the resource's properties.
      /// </summary>
      /// <param name="request">The request received from the client.</param>
      /// <param name="context">The context of the server-side call handler being invoked.</param>
      /// <returns>The response to send back to the client (wrapped by a task).</returns>
      public virtual global::System.Threading.Tasks.Task<global::Pulumirpc.DiffResponse> Diff(global::Pulumirpc.DiffRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Create allocates a new instance of the provided resource and returns its unique ID afterwards.  (The input ID
      /// must be blank.)  If this call fails, the resource must not have been created (i.e., it is "transacational").
      /// </summary>
      /// <param name="request">The request received from the client.</param>
      /// <param name="context">The context of the server-side call handler being invoked.</param>
      /// <returns>The response to send back to the client (wrapped by a task).</returns>
      public virtual global::System.Threading.Tasks.Task<global::Pulumirpc.CreateResponse> Create(global::Pulumirpc.CreateRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Update updates an existing resource with new values.
      /// </summary>
      /// <param name="request">The request received from the client.</param>
      /// <param name="context">The context of the server-side call handler being invoked.</param>
      /// <returns>The response to send back to the client (wrapped by a task).</returns>
      public virtual global::System.Threading.Tasks.Task<global::Pulumirpc.UpdateResponse> Update(global::Pulumirpc.UpdateRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// Delete tears down an existing resource with the given ID.  If it fails, the resource is assumed to still exist.
      /// </summary>
      /// <param name="request">The request received from the client.</param>
      /// <param name="context">The context of the server-side call handler being invoked.</param>
      /// <returns>The response to send back to the client (wrapped by a task).</returns>
      public virtual global::System.Threading.Tasks.Task<global::Google.Protobuf.WellKnownTypes.Empty> Delete(global::Pulumirpc.DeleteRequest request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

      /// <summary>
      /// GetPluginInfo returns generic information about this plugin, like its version.
      /// </summary>
      /// <param name="request">The request received from the client.</param>
      /// <param name="context">The context of the server-side call handler being invoked.</param>
      /// <returns>The response to send back to the client (wrapped by a task).</returns>
      public virtual global::System.Threading.Tasks.Task<global::Pulumirpc.PluginInfo> GetPluginInfo(global::Google.Protobuf.WellKnownTypes.Empty request, grpc::ServerCallContext context)
      {
        throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, ""));
      }

    }

    /// <summary>Client for ResourceProvider</summary>
    public partial class ResourceProviderClient : grpc::ClientBase<ResourceProviderClient>
    {
      /// <summary>Creates a new client for ResourceProvider</summary>
      /// <param name="channel">The channel to use to make remote calls.</param>
      public ResourceProviderClient(grpc::Channel channel) : base(channel)
      {
      }
      /// <summary>Creates a new client for ResourceProvider that uses a custom <c>CallInvoker</c>.</summary>
      /// <param name="callInvoker">The callInvoker to use to make remote calls.</param>
      public ResourceProviderClient(grpc::CallInvoker callInvoker) : base(callInvoker)
      {
      }
      /// <summary>Protected parameterless constructor to allow creation of test doubles.</summary>
      protected ResourceProviderClient() : base()
      {
      }
      /// <summary>Protected constructor to allow creation of configured clients.</summary>
      /// <param name="configuration">The client configuration.</param>
      protected ResourceProviderClient(ClientBaseConfiguration configuration) : base(configuration)
      {
      }

      /// <summary>
      /// Configure configures the resource provider with "globals" that control its behavior.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Google.Protobuf.WellKnownTypes.Empty Configure(global::Pulumirpc.ConfigureRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return Configure(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Configure configures the resource provider with "globals" that control its behavior.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Google.Protobuf.WellKnownTypes.Empty Configure(global::Pulumirpc.ConfigureRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_Configure, null, options, request);
      }
      /// <summary>
      /// Configure configures the resource provider with "globals" that control its behavior.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Google.Protobuf.WellKnownTypes.Empty> ConfigureAsync(global::Pulumirpc.ConfigureRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return ConfigureAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Configure configures the resource provider with "globals" that control its behavior.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Google.Protobuf.WellKnownTypes.Empty> ConfigureAsync(global::Pulumirpc.ConfigureRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_Configure, null, options, request);
      }
      /// <summary>
      /// Invoke dynamically executes a built-in function in the provider.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.InvokeResponse Invoke(global::Pulumirpc.InvokeRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return Invoke(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Invoke dynamically executes a built-in function in the provider.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.InvokeResponse Invoke(global::Pulumirpc.InvokeRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_Invoke, null, options, request);
      }
      /// <summary>
      /// Invoke dynamically executes a built-in function in the provider.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.InvokeResponse> InvokeAsync(global::Pulumirpc.InvokeRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return InvokeAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Invoke dynamically executes a built-in function in the provider.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.InvokeResponse> InvokeAsync(global::Pulumirpc.InvokeRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_Invoke, null, options, request);
      }
      /// <summary>
      /// Check validates that the given property bag is valid for a resource of the given type and returns the inputs
      /// that should be passed to successive calls to Diff, Create, or Update for this resource. As a rule, the provider
      /// inputs returned by a call to Check should preserve the original representation of the properties as present in
      /// the program inputs. Though this rule is not required for correctness, violations thereof can negatively impact
      /// the end-user experience, as the provider inputs are using for detecting and rendering diffs.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.CheckResponse Check(global::Pulumirpc.CheckRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return Check(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Check validates that the given property bag is valid for a resource of the given type and returns the inputs
      /// that should be passed to successive calls to Diff, Create, or Update for this resource. As a rule, the provider
      /// inputs returned by a call to Check should preserve the original representation of the properties as present in
      /// the program inputs. Though this rule is not required for correctness, violations thereof can negatively impact
      /// the end-user experience, as the provider inputs are using for detecting and rendering diffs.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.CheckResponse Check(global::Pulumirpc.CheckRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_Check, null, options, request);
      }
      /// <summary>
      /// Check validates that the given property bag is valid for a resource of the given type and returns the inputs
      /// that should be passed to successive calls to Diff, Create, or Update for this resource. As a rule, the provider
      /// inputs returned by a call to Check should preserve the original representation of the properties as present in
      /// the program inputs. Though this rule is not required for correctness, violations thereof can negatively impact
      /// the end-user experience, as the provider inputs are using for detecting and rendering diffs.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.CheckResponse> CheckAsync(global::Pulumirpc.CheckRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return CheckAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Check validates that the given property bag is valid for a resource of the given type and returns the inputs
      /// that should be passed to successive calls to Diff, Create, or Update for this resource. As a rule, the provider
      /// inputs returned by a call to Check should preserve the original representation of the properties as present in
      /// the program inputs. Though this rule is not required for correctness, violations thereof can negatively impact
      /// the end-user experience, as the provider inputs are using for detecting and rendering diffs.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.CheckResponse> CheckAsync(global::Pulumirpc.CheckRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_Check, null, options, request);
      }
      /// <summary>
      /// Diff checks what impacts a hypothetical update will have on the resource's properties.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.DiffResponse Diff(global::Pulumirpc.DiffRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return Diff(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Diff checks what impacts a hypothetical update will have on the resource's properties.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.DiffResponse Diff(global::Pulumirpc.DiffRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_Diff, null, options, request);
      }
      /// <summary>
      /// Diff checks what impacts a hypothetical update will have on the resource's properties.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.DiffResponse> DiffAsync(global::Pulumirpc.DiffRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return DiffAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Diff checks what impacts a hypothetical update will have on the resource's properties.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.DiffResponse> DiffAsync(global::Pulumirpc.DiffRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_Diff, null, options, request);
      }
      /// <summary>
      /// Create allocates a new instance of the provided resource and returns its unique ID afterwards.  (The input ID
      /// must be blank.)  If this call fails, the resource must not have been created (i.e., it is "transacational").
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.CreateResponse Create(global::Pulumirpc.CreateRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return Create(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create allocates a new instance of the provided resource and returns its unique ID afterwards.  (The input ID
      /// must be blank.)  If this call fails, the resource must not have been created (i.e., it is "transacational").
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.CreateResponse Create(global::Pulumirpc.CreateRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_Create, null, options, request);
      }
      /// <summary>
      /// Create allocates a new instance of the provided resource and returns its unique ID afterwards.  (The input ID
      /// must be blank.)  If this call fails, the resource must not have been created (i.e., it is "transacational").
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.CreateResponse> CreateAsync(global::Pulumirpc.CreateRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return CreateAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Create allocates a new instance of the provided resource and returns its unique ID afterwards.  (The input ID
      /// must be blank.)  If this call fails, the resource must not have been created (i.e., it is "transacational").
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.CreateResponse> CreateAsync(global::Pulumirpc.CreateRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_Create, null, options, request);
      }
      /// <summary>
      /// Update updates an existing resource with new values.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.UpdateResponse Update(global::Pulumirpc.UpdateRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return Update(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Update updates an existing resource with new values.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.UpdateResponse Update(global::Pulumirpc.UpdateRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_Update, null, options, request);
      }
      /// <summary>
      /// Update updates an existing resource with new values.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.UpdateResponse> UpdateAsync(global::Pulumirpc.UpdateRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return UpdateAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Update updates an existing resource with new values.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.UpdateResponse> UpdateAsync(global::Pulumirpc.UpdateRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_Update, null, options, request);
      }
      /// <summary>
      /// Delete tears down an existing resource with the given ID.  If it fails, the resource is assumed to still exist.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Google.Protobuf.WellKnownTypes.Empty Delete(global::Pulumirpc.DeleteRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return Delete(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete tears down an existing resource with the given ID.  If it fails, the resource is assumed to still exist.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Google.Protobuf.WellKnownTypes.Empty Delete(global::Pulumirpc.DeleteRequest request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_Delete, null, options, request);
      }
      /// <summary>
      /// Delete tears down an existing resource with the given ID.  If it fails, the resource is assumed to still exist.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Google.Protobuf.WellKnownTypes.Empty> DeleteAsync(global::Pulumirpc.DeleteRequest request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return DeleteAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// Delete tears down an existing resource with the given ID.  If it fails, the resource is assumed to still exist.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Google.Protobuf.WellKnownTypes.Empty> DeleteAsync(global::Pulumirpc.DeleteRequest request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_Delete, null, options, request);
      }
      /// <summary>
      /// GetPluginInfo returns generic information about this plugin, like its version.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.PluginInfo GetPluginInfo(global::Google.Protobuf.WellKnownTypes.Empty request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return GetPluginInfo(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// GetPluginInfo returns generic information about this plugin, like its version.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The response received from the server.</returns>
      public virtual global::Pulumirpc.PluginInfo GetPluginInfo(global::Google.Protobuf.WellKnownTypes.Empty request, grpc::CallOptions options)
      {
        return CallInvoker.BlockingUnaryCall(__Method_GetPluginInfo, null, options, request);
      }
      /// <summary>
      /// GetPluginInfo returns generic information about this plugin, like its version.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="headers">The initial metadata to send with the call. This parameter is optional.</param>
      /// <param name="deadline">An optional deadline for the call. The call will be cancelled if deadline is hit.</param>
      /// <param name="cancellationToken">An optional token for canceling the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.PluginInfo> GetPluginInfoAsync(global::Google.Protobuf.WellKnownTypes.Empty request, grpc::Metadata headers = null, DateTime? deadline = null, CancellationToken cancellationToken = default(CancellationToken))
      {
        return GetPluginInfoAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken));
      }
      /// <summary>
      /// GetPluginInfo returns generic information about this plugin, like its version.
      /// </summary>
      /// <param name="request">The request to send to the server.</param>
      /// <param name="options">The options for the call.</param>
      /// <returns>The call object.</returns>
      public virtual grpc::AsyncUnaryCall<global::Pulumirpc.PluginInfo> GetPluginInfoAsync(global::Google.Protobuf.WellKnownTypes.Empty request, grpc::CallOptions options)
      {
        return CallInvoker.AsyncUnaryCall(__Method_GetPluginInfo, null, options, request);
      }
      /// <summary>Creates a new instance of client from given <c>ClientBaseConfiguration</c>.</summary>
      protected override ResourceProviderClient NewInstance(ClientBaseConfiguration configuration)
      {
        return new ResourceProviderClient(configuration);
      }
    }

    /// <summary>Creates service definition that can be registered with a server</summary>
    /// <param name="serviceImpl">An object implementing the server-side handling logic.</param>
    public static grpc::ServerServiceDefinition BindService(ResourceProviderBase serviceImpl)
    {
      return grpc::ServerServiceDefinition.CreateBuilder()
          .AddMethod(__Method_Configure, serviceImpl.Configure)
          .AddMethod(__Method_Invoke, serviceImpl.Invoke)
          .AddMethod(__Method_Check, serviceImpl.Check)
          .AddMethod(__Method_Diff, serviceImpl.Diff)
          .AddMethod(__Method_Create, serviceImpl.Create)
          .AddMethod(__Method_Update, serviceImpl.Update)
          .AddMethod(__Method_Delete, serviceImpl.Delete)
          .AddMethod(__Method_GetPluginInfo, serviceImpl.GetPluginInfo).Build();
    }

  }
}
#endregion