All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BQWithdrawalFulfillmentServiceGrpc Maven / Gradle / Ivy

package com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.42.1)",
    comments = "Source: v10/api/bq_withdrawal_fulfillment_service.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class BQWithdrawalFulfillmentServiceGrpc {

  private BQWithdrawalFulfillmentServiceGrpc() {}

  public static final String SERVICE_NAME = "com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BQWithdrawalFulfillmentService";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor getExchangeWithdrawalFulfillmentMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ExchangeWithdrawalFulfillment",
      requestType = com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExchangeWithdrawalFulfillmentRequest.class,
      responseType = com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getExchangeWithdrawalFulfillmentMethod() {
    io.grpc.MethodDescriptor getExchangeWithdrawalFulfillmentMethod;
    if ((getExchangeWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getExchangeWithdrawalFulfillmentMethod) == null) {
      synchronized (BQWithdrawalFulfillmentServiceGrpc.class) {
        if ((getExchangeWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getExchangeWithdrawalFulfillmentMethod) == null) {
          BQWithdrawalFulfillmentServiceGrpc.getExchangeWithdrawalFulfillmentMethod = getExchangeWithdrawalFulfillmentMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ExchangeWithdrawalFulfillment"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExchangeWithdrawalFulfillmentRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.getDefaultInstance()))
              .setSchemaDescriptor(new BQWithdrawalFulfillmentServiceMethodDescriptorSupplier("ExchangeWithdrawalFulfillment"))
              .build();
        }
      }
    }
    return getExchangeWithdrawalFulfillmentMethod;
  }

  private static volatile io.grpc.MethodDescriptor getExecuteWithdrawalFulfillmentMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ExecuteWithdrawalFulfillment",
      requestType = com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExecuteWithdrawalFulfillmentRequest.class,
      responseType = com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getExecuteWithdrawalFulfillmentMethod() {
    io.grpc.MethodDescriptor getExecuteWithdrawalFulfillmentMethod;
    if ((getExecuteWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getExecuteWithdrawalFulfillmentMethod) == null) {
      synchronized (BQWithdrawalFulfillmentServiceGrpc.class) {
        if ((getExecuteWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getExecuteWithdrawalFulfillmentMethod) == null) {
          BQWithdrawalFulfillmentServiceGrpc.getExecuteWithdrawalFulfillmentMethod = getExecuteWithdrawalFulfillmentMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ExecuteWithdrawalFulfillment"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExecuteWithdrawalFulfillmentRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.getDefaultInstance()))
              .setSchemaDescriptor(new BQWithdrawalFulfillmentServiceMethodDescriptorSupplier("ExecuteWithdrawalFulfillment"))
              .build();
        }
      }
    }
    return getExecuteWithdrawalFulfillmentMethod;
  }

  private static volatile io.grpc.MethodDescriptor getInitiateWithdrawalFulfillmentMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "InitiateWithdrawalFulfillment",
      requestType = com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.InitiateWithdrawalFulfillmentRequest.class,
      responseType = com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getInitiateWithdrawalFulfillmentMethod() {
    io.grpc.MethodDescriptor getInitiateWithdrawalFulfillmentMethod;
    if ((getInitiateWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getInitiateWithdrawalFulfillmentMethod) == null) {
      synchronized (BQWithdrawalFulfillmentServiceGrpc.class) {
        if ((getInitiateWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getInitiateWithdrawalFulfillmentMethod) == null) {
          BQWithdrawalFulfillmentServiceGrpc.getInitiateWithdrawalFulfillmentMethod = getInitiateWithdrawalFulfillmentMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "InitiateWithdrawalFulfillment"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.InitiateWithdrawalFulfillmentRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.getDefaultInstance()))
              .setSchemaDescriptor(new BQWithdrawalFulfillmentServiceMethodDescriptorSupplier("InitiateWithdrawalFulfillment"))
              .build();
        }
      }
    }
    return getInitiateWithdrawalFulfillmentMethod;
  }

  private static volatile io.grpc.MethodDescriptor getNotifyWithdrawalFulfillmentMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "NotifyWithdrawalFulfillment",
      requestType = com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.NotifyWithdrawalFulfillmentRequest.class,
      responseType = com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getNotifyWithdrawalFulfillmentMethod() {
    io.grpc.MethodDescriptor getNotifyWithdrawalFulfillmentMethod;
    if ((getNotifyWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getNotifyWithdrawalFulfillmentMethod) == null) {
      synchronized (BQWithdrawalFulfillmentServiceGrpc.class) {
        if ((getNotifyWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getNotifyWithdrawalFulfillmentMethod) == null) {
          BQWithdrawalFulfillmentServiceGrpc.getNotifyWithdrawalFulfillmentMethod = getNotifyWithdrawalFulfillmentMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "NotifyWithdrawalFulfillment"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.NotifyWithdrawalFulfillmentRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.getDefaultInstance()))
              .setSchemaDescriptor(new BQWithdrawalFulfillmentServiceMethodDescriptorSupplier("NotifyWithdrawalFulfillment"))
              .build();
        }
      }
    }
    return getNotifyWithdrawalFulfillmentMethod;
  }

  private static volatile io.grpc.MethodDescriptor getRequestWithdrawalFulfillmentMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "RequestWithdrawalFulfillment",
      requestType = com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RequestWithdrawalFulfillmentRequest.class,
      responseType = com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getRequestWithdrawalFulfillmentMethod() {
    io.grpc.MethodDescriptor getRequestWithdrawalFulfillmentMethod;
    if ((getRequestWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getRequestWithdrawalFulfillmentMethod) == null) {
      synchronized (BQWithdrawalFulfillmentServiceGrpc.class) {
        if ((getRequestWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getRequestWithdrawalFulfillmentMethod) == null) {
          BQWithdrawalFulfillmentServiceGrpc.getRequestWithdrawalFulfillmentMethod = getRequestWithdrawalFulfillmentMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "RequestWithdrawalFulfillment"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RequestWithdrawalFulfillmentRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.getDefaultInstance()))
              .setSchemaDescriptor(new BQWithdrawalFulfillmentServiceMethodDescriptorSupplier("RequestWithdrawalFulfillment"))
              .build();
        }
      }
    }
    return getRequestWithdrawalFulfillmentMethod;
  }

  private static volatile io.grpc.MethodDescriptor getRetrieveWithdrawalFulfillmentMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "RetrieveWithdrawalFulfillment",
      requestType = com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RetrieveWithdrawalFulfillmentRequest.class,
      responseType = com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getRetrieveWithdrawalFulfillmentMethod() {
    io.grpc.MethodDescriptor getRetrieveWithdrawalFulfillmentMethod;
    if ((getRetrieveWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getRetrieveWithdrawalFulfillmentMethod) == null) {
      synchronized (BQWithdrawalFulfillmentServiceGrpc.class) {
        if ((getRetrieveWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getRetrieveWithdrawalFulfillmentMethod) == null) {
          BQWithdrawalFulfillmentServiceGrpc.getRetrieveWithdrawalFulfillmentMethod = getRetrieveWithdrawalFulfillmentMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "RetrieveWithdrawalFulfillment"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RetrieveWithdrawalFulfillmentRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.getDefaultInstance()))
              .setSchemaDescriptor(new BQWithdrawalFulfillmentServiceMethodDescriptorSupplier("RetrieveWithdrawalFulfillment"))
              .build();
        }
      }
    }
    return getRetrieveWithdrawalFulfillmentMethod;
  }

  private static volatile io.grpc.MethodDescriptor getUpdateWithdrawalFulfillmentMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "UpdateWithdrawalFulfillment",
      requestType = com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.UpdateWithdrawalFulfillmentRequest.class,
      responseType = com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor getUpdateWithdrawalFulfillmentMethod() {
    io.grpc.MethodDescriptor getUpdateWithdrawalFulfillmentMethod;
    if ((getUpdateWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getUpdateWithdrawalFulfillmentMethod) == null) {
      synchronized (BQWithdrawalFulfillmentServiceGrpc.class) {
        if ((getUpdateWithdrawalFulfillmentMethod = BQWithdrawalFulfillmentServiceGrpc.getUpdateWithdrawalFulfillmentMethod) == null) {
          BQWithdrawalFulfillmentServiceGrpc.getUpdateWithdrawalFulfillmentMethod = getUpdateWithdrawalFulfillmentMethod =
              io.grpc.MethodDescriptor.newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateWithdrawalFulfillment"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.UpdateWithdrawalFulfillmentRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment.getDefaultInstance()))
              .setSchemaDescriptor(new BQWithdrawalFulfillmentServiceMethodDescriptorSupplier("UpdateWithdrawalFulfillment"))
              .build();
        }
      }
    }
    return getUpdateWithdrawalFulfillmentMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static BQWithdrawalFulfillmentServiceStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
      new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public BQWithdrawalFulfillmentServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new BQWithdrawalFulfillmentServiceStub(channel, callOptions);
        }
      };
    return BQWithdrawalFulfillmentServiceStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static BQWithdrawalFulfillmentServiceBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
      new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public BQWithdrawalFulfillmentServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new BQWithdrawalFulfillmentServiceBlockingStub(channel, callOptions);
        }
      };
    return BQWithdrawalFulfillmentServiceBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static BQWithdrawalFulfillmentServiceFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory factory =
      new io.grpc.stub.AbstractStub.StubFactory() {
        @java.lang.Override
        public BQWithdrawalFulfillmentServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new BQWithdrawalFulfillmentServiceFutureStub(channel, callOptions);
        }
      };
    return BQWithdrawalFulfillmentServiceFutureStub.newStub(factory, channel);
  }

  /**
   */
  public static abstract class BQWithdrawalFulfillmentServiceImplBase implements io.grpc.BindableService {

    /**
     */
    public void exchangeWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExchangeWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExchangeWithdrawalFulfillmentMethod(), responseObserver);
    }

    /**
     */
    public void executeWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExecuteWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExecuteWithdrawalFulfillmentMethod(), responseObserver);
    }

    /**
     */
    public void initiateWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.InitiateWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getInitiateWithdrawalFulfillmentMethod(), responseObserver);
    }

    /**
     */
    public void notifyWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.NotifyWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getNotifyWithdrawalFulfillmentMethod(), responseObserver);
    }

    /**
     */
    public void requestWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RequestWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRequestWithdrawalFulfillmentMethod(), responseObserver);
    }

    /**
     */
    public void retrieveWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RetrieveWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRetrieveWithdrawalFulfillmentMethod(), responseObserver);
    }

    /**
     */
    public void updateWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.UpdateWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateWithdrawalFulfillmentMethod(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getExchangeWithdrawalFulfillmentMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExchangeWithdrawalFulfillmentRequest,
                com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment>(
                  this, METHODID_EXCHANGE_WITHDRAWAL_FULFILLMENT)))
          .addMethod(
            getExecuteWithdrawalFulfillmentMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExecuteWithdrawalFulfillmentRequest,
                com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment>(
                  this, METHODID_EXECUTE_WITHDRAWAL_FULFILLMENT)))
          .addMethod(
            getInitiateWithdrawalFulfillmentMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.InitiateWithdrawalFulfillmentRequest,
                com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment>(
                  this, METHODID_INITIATE_WITHDRAWAL_FULFILLMENT)))
          .addMethod(
            getNotifyWithdrawalFulfillmentMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.NotifyWithdrawalFulfillmentRequest,
                com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment>(
                  this, METHODID_NOTIFY_WITHDRAWAL_FULFILLMENT)))
          .addMethod(
            getRequestWithdrawalFulfillmentMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RequestWithdrawalFulfillmentRequest,
                com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment>(
                  this, METHODID_REQUEST_WITHDRAWAL_FULFILLMENT)))
          .addMethod(
            getRetrieveWithdrawalFulfillmentMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RetrieveWithdrawalFulfillmentRequest,
                com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment>(
                  this, METHODID_RETRIEVE_WITHDRAWAL_FULFILLMENT)))
          .addMethod(
            getUpdateWithdrawalFulfillmentMethod(),
            io.grpc.stub.ServerCalls.asyncUnaryCall(
              new MethodHandlers<
                com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.UpdateWithdrawalFulfillmentRequest,
                com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment>(
                  this, METHODID_UPDATE_WITHDRAWAL_FULFILLMENT)))
          .build();
    }
  }

  /**
   */
  public static final class BQWithdrawalFulfillmentServiceStub extends io.grpc.stub.AbstractAsyncStub {
    private BQWithdrawalFulfillmentServiceStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected BQWithdrawalFulfillmentServiceStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new BQWithdrawalFulfillmentServiceStub(channel, callOptions);
    }

    /**
     */
    public void exchangeWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExchangeWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getExchangeWithdrawalFulfillmentMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void executeWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExecuteWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getExecuteWithdrawalFulfillmentMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void initiateWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.InitiateWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getInitiateWithdrawalFulfillmentMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void notifyWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.NotifyWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getNotifyWithdrawalFulfillmentMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void requestWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RequestWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRequestWithdrawalFulfillmentMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void retrieveWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RetrieveWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRetrieveWithdrawalFulfillmentMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void updateWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.UpdateWithdrawalFulfillmentRequest request,
        io.grpc.stub.StreamObserver responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpdateWithdrawalFulfillmentMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   */
  public static final class BQWithdrawalFulfillmentServiceBlockingStub extends io.grpc.stub.AbstractBlockingStub {
    private BQWithdrawalFulfillmentServiceBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected BQWithdrawalFulfillmentServiceBlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new BQWithdrawalFulfillmentServiceBlockingStub(channel, callOptions);
    }

    /**
     */
    public com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment exchangeWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExchangeWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getExchangeWithdrawalFulfillmentMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment executeWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExecuteWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getExecuteWithdrawalFulfillmentMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment initiateWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.InitiateWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getInitiateWithdrawalFulfillmentMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment notifyWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.NotifyWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getNotifyWithdrawalFulfillmentMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment requestWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RequestWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRequestWithdrawalFulfillmentMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment retrieveWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RetrieveWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRetrieveWithdrawalFulfillmentMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.redhat.mercury.tradefinance.v10.WithdrawalFulfillmentOuterClass.WithdrawalFulfillment updateWithdrawalFulfillment(com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.UpdateWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpdateWithdrawalFulfillmentMethod(), getCallOptions(), request);
    }
  }

  /**
   */
  public static final class BQWithdrawalFulfillmentServiceFutureStub extends io.grpc.stub.AbstractFutureStub {
    private BQWithdrawalFulfillmentServiceFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected BQWithdrawalFulfillmentServiceFutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new BQWithdrawalFulfillmentServiceFutureStub(channel, callOptions);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture exchangeWithdrawalFulfillment(
        com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExchangeWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getExchangeWithdrawalFulfillmentMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture executeWithdrawalFulfillment(
        com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExecuteWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getExecuteWithdrawalFulfillmentMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture initiateWithdrawalFulfillment(
        com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.InitiateWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getInitiateWithdrawalFulfillmentMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture notifyWithdrawalFulfillment(
        com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.NotifyWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getNotifyWithdrawalFulfillmentMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture requestWithdrawalFulfillment(
        com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RequestWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRequestWithdrawalFulfillmentMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture retrieveWithdrawalFulfillment(
        com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RetrieveWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRetrieveWithdrawalFulfillmentMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture updateWithdrawalFulfillment(
        com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.UpdateWithdrawalFulfillmentRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpdateWithdrawalFulfillmentMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_EXCHANGE_WITHDRAWAL_FULFILLMENT = 0;
  private static final int METHODID_EXECUTE_WITHDRAWAL_FULFILLMENT = 1;
  private static final int METHODID_INITIATE_WITHDRAWAL_FULFILLMENT = 2;
  private static final int METHODID_NOTIFY_WITHDRAWAL_FULFILLMENT = 3;
  private static final int METHODID_REQUEST_WITHDRAWAL_FULFILLMENT = 4;
  private static final int METHODID_RETRIEVE_WITHDRAWAL_FULFILLMENT = 5;
  private static final int METHODID_UPDATE_WITHDRAWAL_FULFILLMENT = 6;

  private static final class MethodHandlers implements
      io.grpc.stub.ServerCalls.UnaryMethod,
      io.grpc.stub.ServerCalls.ServerStreamingMethod,
      io.grpc.stub.ServerCalls.ClientStreamingMethod,
      io.grpc.stub.ServerCalls.BidiStreamingMethod {
    private final BQWithdrawalFulfillmentServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(BQWithdrawalFulfillmentServiceImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
      switch (methodId) {
        case METHODID_EXCHANGE_WITHDRAWAL_FULFILLMENT:
          serviceImpl.exchangeWithdrawalFulfillment((com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExchangeWithdrawalFulfillmentRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_EXECUTE_WITHDRAWAL_FULFILLMENT:
          serviceImpl.executeWithdrawalFulfillment((com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.ExecuteWithdrawalFulfillmentRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_INITIATE_WITHDRAWAL_FULFILLMENT:
          serviceImpl.initiateWithdrawalFulfillment((com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.InitiateWithdrawalFulfillmentRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_NOTIFY_WITHDRAWAL_FULFILLMENT:
          serviceImpl.notifyWithdrawalFulfillment((com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.NotifyWithdrawalFulfillmentRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_REQUEST_WITHDRAWAL_FULFILLMENT:
          serviceImpl.requestWithdrawalFulfillment((com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RequestWithdrawalFulfillmentRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_RETRIEVE_WITHDRAWAL_FULFILLMENT:
          serviceImpl.retrieveWithdrawalFulfillment((com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.RetrieveWithdrawalFulfillmentRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        case METHODID_UPDATE_WITHDRAWAL_FULFILLMENT:
          serviceImpl.updateWithdrawalFulfillment((com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.UpdateWithdrawalFulfillmentRequest) request,
              (io.grpc.stub.StreamObserver) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver invoke(
        io.grpc.stub.StreamObserver responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class BQWithdrawalFulfillmentServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    BQWithdrawalFulfillmentServiceBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return com.redhat.mercury.tradefinance.v10.api.bqwithdrawalfulfillmentservice.BqWithdrawalFulfillmentService.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("BQWithdrawalFulfillmentService");
    }
  }

  private static final class BQWithdrawalFulfillmentServiceFileDescriptorSupplier
      extends BQWithdrawalFulfillmentServiceBaseDescriptorSupplier {
    BQWithdrawalFulfillmentServiceFileDescriptorSupplier() {}
  }

  private static final class BQWithdrawalFulfillmentServiceMethodDescriptorSupplier
      extends BQWithdrawalFulfillmentServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    BQWithdrawalFulfillmentServiceMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (BQWithdrawalFulfillmentServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new BQWithdrawalFulfillmentServiceFileDescriptorSupplier())
              .addMethod(getExchangeWithdrawalFulfillmentMethod())
              .addMethod(getExecuteWithdrawalFulfillmentMethod())
              .addMethod(getInitiateWithdrawalFulfillmentMethod())
              .addMethod(getNotifyWithdrawalFulfillmentMethod())
              .addMethod(getRequestWithdrawalFulfillmentMethod())
              .addMethod(getRetrieveWithdrawalFulfillmentMethod())
              .addMethod(getUpdateWithdrawalFulfillmentMethod())
              .build();
        }
      }
    }
    return result;
  }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy