grpc-js: Add xDS interop client and associated generated code

packages/grpc-js/interop/generated/grpc/testing/BoolValue.ts

@@ -0,0 +1,26 @@
+// Original file: proto/grpc/testing/messages.proto
+
+
+/**
+ * TODO(dgq): Go back to using well-known types once
+ * https://github.com/grpc/grpc/issues/6980 has been fixed.
+ * import "google/protobuf/wrappers.proto";
+ */
+export interface BoolValue {
+  /**
+   * The bool value.
+   */
+  'value'?: (boolean);
+}
+
+/**
+ * TODO(dgq): Go back to using well-known types once
+ * https://github.com/grpc/grpc/issues/6980 has been fixed.
+ * import "google/protobuf/wrappers.proto";
+ */
+export interface BoolValue__Output {
+  /**
+   * The bool value.
+   */
+  'value': (boolean);
+}

packages/grpc-js/interop/generated/grpc/testing/EchoStatus.ts

@@ -0,0 +1,20 @@
+// Original file: proto/grpc/testing/messages.proto
+
+
+/**
+ * A protobuf representation for grpc status. This is used by test
+ * clients to specify a status that the server should attempt to return.
+ */
+export interface EchoStatus {
+  'code'?: (number);
+  'message'?: (string);
+}
+
+/**
+ * A protobuf representation for grpc status. This is used by test
+ * clients to specify a status that the server should attempt to return.
+ */
+export interface EchoStatus__Output {
+  'code': (number);
+  'message': (string);
+}

packages/grpc-js/interop/generated/grpc/testing/Empty.ts

@@ -0,0 +1,26 @@
+// Original file: proto/grpc/testing/empty.proto
+
+
+/**
+ * An empty message that you can re-use to avoid defining duplicated empty
+ * messages in your project. A typical example is to use it as argument or the
+ * return value of a service API. For instance:
+ * 
+ * service Foo {
+ * rpc Bar (grpc.testing.Empty) returns (grpc.testing.Empty) { };
+ * };
+ */
+export interface Empty {
+}
+
+/**
+ * An empty message that you can re-use to avoid defining duplicated empty
+ * messages in your project. A typical example is to use it as argument or the
+ * return value of a service API. For instance:
+ * 
+ * service Foo {
+ * rpc Bar (grpc.testing.Empty) returns (grpc.testing.Empty) { };
+ * };
+ */
+export interface Empty__Output {
+}

packages/grpc-js/interop/generated/grpc/testing/GrpclbRouteType.ts

@@ -0,0 +1,24 @@
+// Original file: proto/grpc/testing/messages.proto
+
+/**
+ * The type of route that a client took to reach a server w.r.t. gRPCLB.
+ * The server must fill in "fallback" if it detects that the RPC reached
+ * the server via the "gRPCLB fallback" path, and "backend" if it detects
+ * that the RPC reached the server via "gRPCLB backend" path (i.e. if it got
+ * the address of this server from the gRPCLB server BalanceLoad RPC). Exactly
+ * how this detection is done is context and server dependent.
+ */
+export enum GrpclbRouteType {
+  /**
+   * Server didn't detect the route that a client took to reach it.
+   */
+  GRPCLB_ROUTE_TYPE_UNKNOWN = 0,
+  /**
+   * Indicates that a client reached a server via gRPCLB fallback.
+   */
+  GRPCLB_ROUTE_TYPE_FALLBACK = 1,
+  /**
+   * Indicates that a client reached a server as a gRPCLB-given backend.
+   */
+  GRPCLB_ROUTE_TYPE_BACKEND = 2,
+}

packages/grpc-js/interop/generated/grpc/testing/LoadBalancerStatsRequest.ts

@@ -0,0 +1,24 @@
+// Original file: proto/grpc/testing/messages.proto
+
+
+export interface LoadBalancerStatsRequest {
+  /**
+   * Request stats for the next num_rpcs sent by client.
+   */
+  'num_rpcs'?: (number);
+  /**
+   * If num_rpcs have not completed within timeout_sec, return partial results.
+   */
+  'timeout_sec'?: (number);
+}
+
+export interface LoadBalancerStatsRequest__Output {
+  /**
+   * Request stats for the next num_rpcs sent by client.
+   */
+  'num_rpcs': (number);
+  /**
+   * If num_rpcs have not completed within timeout_sec, return partial results.
+   */
+  'timeout_sec': (number);
+}

packages/grpc-js/interop/generated/grpc/testing/LoadBalancerStatsResponse.ts

@@ -0,0 +1,40 @@
+// Original file: proto/grpc/testing/messages.proto
+
+
+export interface _grpc_testing_LoadBalancerStatsResponse_RpcsByPeer {
+  /**
+   * The number of completed RPCs for each peer.
+   */
+  'rpcs_by_peer'?: ({[key: string]: number});
+}
+
+export interface _grpc_testing_LoadBalancerStatsResponse_RpcsByPeer__Output {
+  /**
+   * The number of completed RPCs for each peer.
+   */
+  'rpcs_by_peer': ({[key: string]: number});
+}
+
+export interface LoadBalancerStatsResponse {
+  /**
+   * The number of completed RPCs for each peer.
+   */
+  'rpcs_by_peer'?: ({[key: string]: number});
+  /**
+   * The number of RPCs that failed to record a remote peer.
+   */
+  'num_failures'?: (number);
+  'rpcs_by_method'?: ({[key: string]: _grpc_testing_LoadBalancerStatsResponse_RpcsByPeer});
+}
+
+export interface LoadBalancerStatsResponse__Output {
+  /**
+   * The number of completed RPCs for each peer.
+   */
+  'rpcs_by_peer': ({[key: string]: number});
+  /**
+   * The number of RPCs that failed to record a remote peer.
+   */
+  'num_failures': (number);
+  'rpcs_by_method'?: ({[key: string]: _grpc_testing_LoadBalancerStatsResponse_RpcsByPeer__Output});
+}

packages/grpc-js/interop/generated/grpc/testing/LoadBalancerStatsService.ts

@@ -0,0 +1,37 @@
+// Original file: proto/grpc/testing/test.proto
+
+import * as grpc from '../../../../src'
+import { LoadBalancerStatsRequest as _grpc_testing_LoadBalancerStatsRequest, LoadBalancerStatsRequest__Output as _grpc_testing_LoadBalancerStatsRequest__Output } from '../../grpc/testing/LoadBalancerStatsRequest';
+import { LoadBalancerStatsResponse as _grpc_testing_LoadBalancerStatsResponse, LoadBalancerStatsResponse__Output as _grpc_testing_LoadBalancerStatsResponse__Output } from '../../grpc/testing/LoadBalancerStatsResponse';
+
+/**
+ * A service used to obtain stats for verifying LB behavior.
+ */
+export interface LoadBalancerStatsServiceClient extends grpc.Client {
+  /**
+   * Gets the backend distribution for RPCs sent by a test client.
+   */
+  GetClientStats(argument: _grpc_testing_LoadBalancerStatsRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_LoadBalancerStatsResponse__Output) => void): grpc.ClientUnaryCall;
+  GetClientStats(argument: _grpc_testing_LoadBalancerStatsRequest, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_LoadBalancerStatsResponse__Output) => void): grpc.ClientUnaryCall;
+  GetClientStats(argument: _grpc_testing_LoadBalancerStatsRequest, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_LoadBalancerStatsResponse__Output) => void): grpc.ClientUnaryCall;
+  GetClientStats(argument: _grpc_testing_LoadBalancerStatsRequest, callback: (error?: grpc.ServiceError, result?: _grpc_testing_LoadBalancerStatsResponse__Output) => void): grpc.ClientUnaryCall;
+  /**
+   * Gets the backend distribution for RPCs sent by a test client.
+   */
+  getClientStats(argument: _grpc_testing_LoadBalancerStatsRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_LoadBalancerStatsResponse__Output) => void): grpc.ClientUnaryCall;
+  getClientStats(argument: _grpc_testing_LoadBalancerStatsRequest, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_LoadBalancerStatsResponse__Output) => void): grpc.ClientUnaryCall;
+  getClientStats(argument: _grpc_testing_LoadBalancerStatsRequest, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_LoadBalancerStatsResponse__Output) => void): grpc.ClientUnaryCall;
+  getClientStats(argument: _grpc_testing_LoadBalancerStatsRequest, callback: (error?: grpc.ServiceError, result?: _grpc_testing_LoadBalancerStatsResponse__Output) => void): grpc.ClientUnaryCall;
+  
+}
+
+/**
+ * A service used to obtain stats for verifying LB behavior.
+ */
+export interface LoadBalancerStatsServiceHandlers extends grpc.UntypedServiceImplementation {
+  /**
+   * Gets the backend distribution for RPCs sent by a test client.
+   */
+  GetClientStats(call: grpc.ServerUnaryCall<_grpc_testing_LoadBalancerStatsRequest__Output, _grpc_testing_LoadBalancerStatsResponse>, callback: grpc.sendUnaryData<_grpc_testing_LoadBalancerStatsResponse>): void;
+  
+}

packages/grpc-js/interop/generated/grpc/testing/Payload.ts

@@ -0,0 +1,31 @@
+// Original file: proto/grpc/testing/messages.proto
+
+import { PayloadType as _grpc_testing_PayloadType } from '../../grpc/testing/PayloadType';
+
+/**
+ * A block of data, to simply increase gRPC message size.
+ */
+export interface Payload {
+  /**
+   * The type of data in body.
+   */
+  'type'?: (_grpc_testing_PayloadType | keyof typeof _grpc_testing_PayloadType);
+  /**
+   * Primary contents of payload.
+   */
+  'body'?: (Buffer | Uint8Array | string);
+}
+
+/**
+ * A block of data, to simply increase gRPC message size.
+ */
+export interface Payload__Output {
+  /**
+   * The type of data in body.
+   */
+  'type': (keyof typeof _grpc_testing_PayloadType);
+  /**
+   * Primary contents of payload.
+   */
+  'body': (Buffer);
+}

packages/grpc-js/interop/generated/grpc/testing/PayloadType.ts

@@ -0,0 +1,11 @@
+// Original file: proto/grpc/testing/messages.proto
+
+/**
+ * The type of payload that should be returned.
+ */
+export enum PayloadType {
+  /**
+   * Compressable text format.
+   */
+  COMPRESSABLE = 0,
+}

packages/grpc-js/interop/generated/grpc/testing/ReconnectInfo.ts

@@ -0,0 +1,22 @@
+// Original file: proto/grpc/testing/messages.proto
+
+
+/**
+ * For reconnect interop test only.
+ * Server tells client whether its reconnects are following the spec and the
+ * reconnect backoffs it saw.
+ */
+export interface ReconnectInfo {
+  'passed'?: (boolean);
+  'backoff_ms'?: (number)[];
+}
+
+/**
+ * For reconnect interop test only.
+ * Server tells client whether its reconnects are following the spec and the
+ * reconnect backoffs it saw.
+ */
+export interface ReconnectInfo__Output {
+  'passed': (boolean);
+  'backoff_ms': (number)[];
+}

packages/grpc-js/interop/generated/grpc/testing/ReconnectParams.ts

@@ -0,0 +1,18 @@
+// Original file: proto/grpc/testing/messages.proto
+
+
+/**
+ * For reconnect interop test only.
+ * Client tells server what reconnection parameters it used.
+ */
+export interface ReconnectParams {
+  'max_reconnect_backoff_ms'?: (number);
+}
+
+/**
+ * For reconnect interop test only.
+ * Client tells server what reconnection parameters it used.
+ */
+export interface ReconnectParams__Output {
+  'max_reconnect_backoff_ms': (number);
+}

packages/grpc-js/interop/generated/grpc/testing/ReconnectService.ts

@@ -0,0 +1,40 @@
+// Original file: proto/grpc/testing/test.proto
+
+import * as grpc from '../../../../src'
+import { Empty as _grpc_testing_Empty, Empty__Output as _grpc_testing_Empty__Output } from '../../grpc/testing/Empty';
+import { ReconnectInfo as _grpc_testing_ReconnectInfo, ReconnectInfo__Output as _grpc_testing_ReconnectInfo__Output } from '../../grpc/testing/ReconnectInfo';
+import { ReconnectParams as _grpc_testing_ReconnectParams, ReconnectParams__Output as _grpc_testing_ReconnectParams__Output } from '../../grpc/testing/ReconnectParams';
+
+/**
+ * A service used to control reconnect server.
+ */
+export interface ReconnectServiceClient extends grpc.Client {
+  Start(argument: _grpc_testing_ReconnectParams, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  Start(argument: _grpc_testing_ReconnectParams, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  Start(argument: _grpc_testing_ReconnectParams, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  Start(argument: _grpc_testing_ReconnectParams, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  start(argument: _grpc_testing_ReconnectParams, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  start(argument: _grpc_testing_ReconnectParams, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  start(argument: _grpc_testing_ReconnectParams, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  start(argument: _grpc_testing_ReconnectParams, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  
+  Stop(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_ReconnectInfo__Output) => void): grpc.ClientUnaryCall;
+  Stop(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_ReconnectInfo__Output) => void): grpc.ClientUnaryCall;
+  Stop(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_ReconnectInfo__Output) => void): grpc.ClientUnaryCall;
+  Stop(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_ReconnectInfo__Output) => void): grpc.ClientUnaryCall;
+  stop(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_ReconnectInfo__Output) => void): grpc.ClientUnaryCall;
+  stop(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_ReconnectInfo__Output) => void): grpc.ClientUnaryCall;
+  stop(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_ReconnectInfo__Output) => void): grpc.ClientUnaryCall;
+  stop(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_ReconnectInfo__Output) => void): grpc.ClientUnaryCall;
+  
+}
+
+/**
+ * A service used to control reconnect server.
+ */
+export interface ReconnectServiceHandlers extends grpc.UntypedServiceImplementation {
+  Start(call: grpc.ServerUnaryCall<_grpc_testing_ReconnectParams__Output, _grpc_testing_Empty>, callback: grpc.sendUnaryData<_grpc_testing_Empty>): void;
+  
+  Stop(call: grpc.ServerUnaryCall<_grpc_testing_Empty__Output, _grpc_testing_ReconnectInfo>, callback: grpc.sendUnaryData<_grpc_testing_ReconnectInfo>): void;
+  
+}

packages/grpc-js/interop/generated/grpc/testing/ResponseParameters.ts

@@ -0,0 +1,47 @@
+// Original file: proto/grpc/testing/messages.proto
+
+import { BoolValue as _grpc_testing_BoolValue, BoolValue__Output as _grpc_testing_BoolValue__Output } from '../../grpc/testing/BoolValue';
+
+/**
+ * Configuration for a particular response.
+ */
+export interface ResponseParameters {
+  /**
+   * Desired payload sizes in responses from the server.
+   */
+  'size'?: (number);
+  /**
+   * Desired interval between consecutive responses in the response stream in
+   * microseconds.
+   */
+  'interval_us'?: (number);
+  /**
+   * Whether to request the server to compress the response. This field is
+   * "nullable" in order to interoperate seamlessly with clients not able to
+   * implement the full compression tests by introspecting the call to verify
+   * the response's compression status.
+   */
+  'compressed'?: (_grpc_testing_BoolValue);
+}
+
+/**
+ * Configuration for a particular response.
+ */
+export interface ResponseParameters__Output {
+  /**
+   * Desired payload sizes in responses from the server.
+   */
+  'size': (number);
+  /**
+   * Desired interval between consecutive responses in the response stream in
+   * microseconds.
+   */
+  'interval_us': (number);
+  /**
+   * Whether to request the server to compress the response. This field is
+   * "nullable" in order to interoperate seamlessly with clients not able to
+   * implement the full compression tests by introspecting the call to verify
+   * the response's compression status.
+   */
+  'compressed'?: (_grpc_testing_BoolValue__Output);
+}

packages/grpc-js/interop/generated/grpc/testing/SimpleRequest.ts

@@ -0,0 +1,106 @@
+// Original file: proto/grpc/testing/messages.proto
+
+import { PayloadType as _grpc_testing_PayloadType } from '../../grpc/testing/PayloadType';
+import { Payload as _grpc_testing_Payload, Payload__Output as _grpc_testing_Payload__Output } from '../../grpc/testing/Payload';
+import { BoolValue as _grpc_testing_BoolValue, BoolValue__Output as _grpc_testing_BoolValue__Output } from '../../grpc/testing/BoolValue';
+import { EchoStatus as _grpc_testing_EchoStatus, EchoStatus__Output as _grpc_testing_EchoStatus__Output } from '../../grpc/testing/EchoStatus';
+
+/**
+ * Unary request.
+ */
+export interface SimpleRequest {
+  /**
+   * Desired payload type in the response from the server.
+   * If response_type is RANDOM, server randomly chooses one from other formats.
+   */
+  'response_type'?: (_grpc_testing_PayloadType | keyof typeof _grpc_testing_PayloadType);
+  /**
+   * Desired payload size in the response from the server.
+   */
+  'response_size'?: (number);
+  /**
+   * Optional input payload sent along with the request.
+   */
+  'payload'?: (_grpc_testing_Payload);
+  /**
+   * Whether SimpleResponse should include username.
+   */
+  'fill_username'?: (boolean);
+  /**
+   * Whether SimpleResponse should include OAuth scope.
+   */
+  'fill_oauth_scope'?: (boolean);
+  /**
+   * Whether to request the server to compress the response. This field is
+   * "nullable" in order to interoperate seamlessly with clients not able to
+   * implement the full compression tests by introspecting the call to verify
+   * the response's compression status.
+   */
+  'response_compressed'?: (_grpc_testing_BoolValue);
+  /**
+   * Whether server should return a given status
+   */
+  'response_status'?: (_grpc_testing_EchoStatus);
+  /**
+   * Whether the server should expect this request to be compressed.
+   */
+  'expect_compressed'?: (_grpc_testing_BoolValue);
+  /**
+   * Whether SimpleResponse should include server_id.
+   */
+  'fill_server_id'?: (boolean);
+  /**
+   * Whether SimpleResponse should include grpclb_route_type.
+   */
+  'fill_grpclb_route_type'?: (boolean);
+}
+
+/**
+ * Unary request.
+ */
+export interface SimpleRequest__Output {
+  /**
+   * Desired payload type in the response from the server.
+   * If response_type is RANDOM, server randomly chooses one from other formats.
+   */
+  'response_type': (keyof typeof _grpc_testing_PayloadType);
+  /**
+   * Desired payload size in the response from the server.
+   */
+  'response_size': (number);
+  /**
+   * Optional input payload sent along with the request.
+   */
+  'payload'?: (_grpc_testing_Payload__Output);
+  /**
+   * Whether SimpleResponse should include username.
+   */
+  'fill_username': (boolean);
+  /**
+   * Whether SimpleResponse should include OAuth scope.
+   */
+  'fill_oauth_scope': (boolean);
+  /**
+   * Whether to request the server to compress the response. This field is
+   * "nullable" in order to interoperate seamlessly with clients not able to
+   * implement the full compression tests by introspecting the call to verify
+   * the response's compression status.
+   */
+  'response_compressed'?: (_grpc_testing_BoolValue__Output);
+  /**
+   * Whether server should return a given status
+   */
+  'response_status'?: (_grpc_testing_EchoStatus__Output);
+  /**
+   * Whether the server should expect this request to be compressed.
+   */
+  'expect_compressed'?: (_grpc_testing_BoolValue__Output);
+  /**
+   * Whether SimpleResponse should include server_id.
+   */
+  'fill_server_id': (boolean);
+  /**
+   * Whether SimpleResponse should include grpclb_route_type.
+   */
+  'fill_grpclb_route_type': (boolean);
+}

packages/grpc-js/interop/generated/grpc/testing/SimpleResponse.ts

@@ -0,0 +1,68 @@
+// Original file: proto/grpc/testing/messages.proto
+
+import { Payload as _grpc_testing_Payload, Payload__Output as _grpc_testing_Payload__Output } from '../../grpc/testing/Payload';
+import { GrpclbRouteType as _grpc_testing_GrpclbRouteType } from '../../grpc/testing/GrpclbRouteType';
+
+/**
+ * Unary response, as configured by the request.
+ */
+export interface SimpleResponse {
+  /**
+   * Payload to increase message size.
+   */
+  'payload'?: (_grpc_testing_Payload);
+  /**
+   * The user the request came from, for verifying authentication was
+   * successful when the client expected it.
+   */
+  'username'?: (string);
+  /**
+   * OAuth scope.
+   */
+  'oauth_scope'?: (string);
+  /**
+   * Server ID. This must be unique among different server instances,
+   * but the same across all RPC's made to a particular server instance.
+   */
+  'server_id'?: (string);
+  /**
+   * gRPCLB Path.
+   */
+  'grpclb_route_type'?: (_grpc_testing_GrpclbRouteType | keyof typeof _grpc_testing_GrpclbRouteType);
+  /**
+   * Server hostname.
+   */
+  'hostname'?: (string);
+}
+
+/**
+ * Unary response, as configured by the request.
+ */
+export interface SimpleResponse__Output {
+  /**
+   * Payload to increase message size.
+   */
+  'payload'?: (_grpc_testing_Payload__Output);
+  /**
+   * The user the request came from, for verifying authentication was
+   * successful when the client expected it.
+   */
+  'username': (string);
+  /**
+   * OAuth scope.
+   */
+  'oauth_scope': (string);
+  /**
+   * Server ID. This must be unique among different server instances,
+   * but the same across all RPC's made to a particular server instance.
+   */
+  'server_id': (string);
+  /**
+   * gRPCLB Path.
+   */
+  'grpclb_route_type': (keyof typeof _grpc_testing_GrpclbRouteType);
+  /**
+   * Server hostname.
+   */
+  'hostname': (string);
+}

packages/grpc-js/interop/generated/grpc/testing/StreamingInputCallRequest.ts

@@ -0,0 +1,38 @@
+// Original file: proto/grpc/testing/messages.proto
+
+import { Payload as _grpc_testing_Payload, Payload__Output as _grpc_testing_Payload__Output } from '../../grpc/testing/Payload';
+import { BoolValue as _grpc_testing_BoolValue, BoolValue__Output as _grpc_testing_BoolValue__Output } from '../../grpc/testing/BoolValue';
+
+/**
+ * Client-streaming request.
+ */
+export interface StreamingInputCallRequest {
+  /**
+   * Optional input payload sent along with the request.
+   */
+  'payload'?: (_grpc_testing_Payload);
+  /**
+   * Whether the server should expect this request to be compressed. This field
+   * is "nullable" in order to interoperate seamlessly with servers not able to
+   * implement the full compression tests by introspecting the call to verify
+   * the request's compression status.
+   */
+  'expect_compressed'?: (_grpc_testing_BoolValue);
+}
+
+/**
+ * Client-streaming request.
+ */
+export interface StreamingInputCallRequest__Output {
+  /**
+   * Optional input payload sent along with the request.
+   */
+  'payload'?: (_grpc_testing_Payload__Output);
+  /**
+   * Whether the server should expect this request to be compressed. This field
+   * is "nullable" in order to interoperate seamlessly with servers not able to
+   * implement the full compression tests by introspecting the call to verify
+   * the request's compression status.
+   */
+  'expect_compressed'?: (_grpc_testing_BoolValue__Output);
+}

packages/grpc-js/interop/generated/grpc/testing/StreamingInputCallResponse.ts

@@ -0,0 +1,22 @@
+// Original file: proto/grpc/testing/messages.proto
+
+
+/**
+ * Client-streaming response.
+ */
+export interface StreamingInputCallResponse {
+  /**
+   * Aggregated size of payloads received from the client.
+   */
+  'aggregated_payload_size'?: (number);
+}
+
+/**
+ * Client-streaming response.
+ */
+export interface StreamingInputCallResponse__Output {
+  /**
+   * Aggregated size of payloads received from the client.
+   */
+  'aggregated_payload_size': (number);
+}

packages/grpc-js/interop/generated/grpc/testing/StreamingOutputCallRequest.ts

@@ -0,0 +1,56 @@
+// Original file: proto/grpc/testing/messages.proto
+
+import { PayloadType as _grpc_testing_PayloadType } from '../../grpc/testing/PayloadType';
+import { ResponseParameters as _grpc_testing_ResponseParameters, ResponseParameters__Output as _grpc_testing_ResponseParameters__Output } from '../../grpc/testing/ResponseParameters';
+import { Payload as _grpc_testing_Payload, Payload__Output as _grpc_testing_Payload__Output } from '../../grpc/testing/Payload';
+import { EchoStatus as _grpc_testing_EchoStatus, EchoStatus__Output as _grpc_testing_EchoStatus__Output } from '../../grpc/testing/EchoStatus';
+
+/**
+ * Server-streaming request.
+ */
+export interface StreamingOutputCallRequest {
+  /**
+   * Desired payload type in the response from the server.
+   * If response_type is RANDOM, the payload from each response in the stream
+   * might be of different types. This is to simulate a mixed type of payload
+   * stream.
+   */
+  'response_type'?: (_grpc_testing_PayloadType | keyof typeof _grpc_testing_PayloadType);
+  /**
+   * Configuration for each expected response message.
+   */
+  'response_parameters'?: (_grpc_testing_ResponseParameters)[];
+  /**
+   * Optional input payload sent along with the request.
+   */
+  'payload'?: (_grpc_testing_Payload);
+  /**
+   * Whether server should return a given status
+   */
+  'response_status'?: (_grpc_testing_EchoStatus);
+}
+
+/**
+ * Server-streaming request.
+ */
+export interface StreamingOutputCallRequest__Output {
+  /**
+   * Desired payload type in the response from the server.
+   * If response_type is RANDOM, the payload from each response in the stream
+   * might be of different types. This is to simulate a mixed type of payload
+   * stream.
+   */
+  'response_type': (keyof typeof _grpc_testing_PayloadType);
+  /**
+   * Configuration for each expected response message.
+   */
+  'response_parameters': (_grpc_testing_ResponseParameters__Output)[];
+  /**
+   * Optional input payload sent along with the request.
+   */
+  'payload'?: (_grpc_testing_Payload__Output);
+  /**
+   * Whether server should return a given status
+   */
+  'response_status'?: (_grpc_testing_EchoStatus__Output);
+}

packages/grpc-js/interop/generated/grpc/testing/StreamingOutputCallResponse.ts

@@ -0,0 +1,23 @@
+// Original file: proto/grpc/testing/messages.proto
+
+import { Payload as _grpc_testing_Payload, Payload__Output as _grpc_testing_Payload__Output } from '../../grpc/testing/Payload';
+
+/**
+ * Server-streaming response, as configured by the request and parameters.
+ */
+export interface StreamingOutputCallResponse {
+  /**
+   * Payload to increase response size.
+   */
+  'payload'?: (_grpc_testing_Payload);
+}
+
+/**
+ * Server-streaming response, as configured by the request and parameters.
+ */
+export interface StreamingOutputCallResponse__Output {
+  /**
+   * Payload to increase response size.
+   */
+  'payload'?: (_grpc_testing_Payload__Output);
+}

packages/grpc-js/interop/generated/grpc/testing/TestService.ts

@@ -0,0 +1,202 @@
+// Original file: proto/grpc/testing/test.proto
+
+import * as grpc from '../../../../src'
+import { Empty as _grpc_testing_Empty, Empty__Output as _grpc_testing_Empty__Output } from '../../grpc/testing/Empty';
+import { SimpleRequest as _grpc_testing_SimpleRequest, SimpleRequest__Output as _grpc_testing_SimpleRequest__Output } from '../../grpc/testing/SimpleRequest';
+import { SimpleResponse as _grpc_testing_SimpleResponse, SimpleResponse__Output as _grpc_testing_SimpleResponse__Output } from '../../grpc/testing/SimpleResponse';
+import { StreamingInputCallRequest as _grpc_testing_StreamingInputCallRequest, StreamingInputCallRequest__Output as _grpc_testing_StreamingInputCallRequest__Output } from '../../grpc/testing/StreamingInputCallRequest';
+import { StreamingInputCallResponse as _grpc_testing_StreamingInputCallResponse, StreamingInputCallResponse__Output as _grpc_testing_StreamingInputCallResponse__Output } from '../../grpc/testing/StreamingInputCallResponse';
+import { StreamingOutputCallRequest as _grpc_testing_StreamingOutputCallRequest, StreamingOutputCallRequest__Output as _grpc_testing_StreamingOutputCallRequest__Output } from '../../grpc/testing/StreamingOutputCallRequest';
+import { StreamingOutputCallResponse as _grpc_testing_StreamingOutputCallResponse, StreamingOutputCallResponse__Output as _grpc_testing_StreamingOutputCallResponse__Output } from '../../grpc/testing/StreamingOutputCallResponse';
+
+/**
+ * A simple service to test the various types of RPCs and experiment with
+ * performance with various types of payload.
+ */
+export interface TestServiceClient extends grpc.Client {
+  /**
+   * One request followed by one response. Response has cache control
+   * headers set such that a caching HTTP proxy (such as GFE) can
+   * satisfy subsequent requests.
+   */
+  CacheableUnaryCall(argument: _grpc_testing_SimpleRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  CacheableUnaryCall(argument: _grpc_testing_SimpleRequest, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  CacheableUnaryCall(argument: _grpc_testing_SimpleRequest, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  CacheableUnaryCall(argument: _grpc_testing_SimpleRequest, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  /**
+   * One request followed by one response. Response has cache control
+   * headers set such that a caching HTTP proxy (such as GFE) can
+   * satisfy subsequent requests.
+   */
+  cacheableUnaryCall(argument: _grpc_testing_SimpleRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  cacheableUnaryCall(argument: _grpc_testing_SimpleRequest, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  cacheableUnaryCall(argument: _grpc_testing_SimpleRequest, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  cacheableUnaryCall(argument: _grpc_testing_SimpleRequest, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  
+  /**
+   * One empty request followed by one empty response.
+   */
+  EmptyCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  EmptyCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  EmptyCall(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  EmptyCall(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  /**
+   * One empty request followed by one empty response.
+   */
+  emptyCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  emptyCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  emptyCall(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  emptyCall(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  
+  /**
+   * A sequence of requests with each request served by the server immediately.
+   * As one request could lead to multiple responses, this interface
+   * demonstrates the idea of full duplexing.
+   */
+  FullDuplexCall(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_grpc_testing_StreamingOutputCallRequest, _grpc_testing_StreamingOutputCallResponse__Output>;
+  FullDuplexCall(options?: grpc.CallOptions): grpc.ClientDuplexStream<_grpc_testing_StreamingOutputCallRequest, _grpc_testing_StreamingOutputCallResponse__Output>;
+  /**
+   * A sequence of requests with each request served by the server immediately.
+   * As one request could lead to multiple responses, this interface
+   * demonstrates the idea of full duplexing.
+   */
+  fullDuplexCall(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_grpc_testing_StreamingOutputCallRequest, _grpc_testing_StreamingOutputCallResponse__Output>;
+  fullDuplexCall(options?: grpc.CallOptions): grpc.ClientDuplexStream<_grpc_testing_StreamingOutputCallRequest, _grpc_testing_StreamingOutputCallResponse__Output>;
+  
+  /**
+   * A sequence of requests followed by a sequence of responses.
+   * The server buffers all the client requests and then serves them in order. A
+   * stream of responses are returned to the client when the server starts with
+   * first request.
+   */
+  HalfDuplexCall(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_grpc_testing_StreamingOutputCallRequest, _grpc_testing_StreamingOutputCallResponse__Output>;
+  HalfDuplexCall(options?: grpc.CallOptions): grpc.ClientDuplexStream<_grpc_testing_StreamingOutputCallRequest, _grpc_testing_StreamingOutputCallResponse__Output>;
+  /**
+   * A sequence of requests followed by a sequence of responses.
+   * The server buffers all the client requests and then serves them in order. A
+   * stream of responses are returned to the client when the server starts with
+   * first request.
+   */
+  halfDuplexCall(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<_grpc_testing_StreamingOutputCallRequest, _grpc_testing_StreamingOutputCallResponse__Output>;
+  halfDuplexCall(options?: grpc.CallOptions): grpc.ClientDuplexStream<_grpc_testing_StreamingOutputCallRequest, _grpc_testing_StreamingOutputCallResponse__Output>;
+  
+  /**
+   * A sequence of requests followed by one response (streamed upload).
+   * The server returns the aggregated size of client payload as the result.
+   */
+  StreamingInputCall(metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_StreamingInputCallResponse__Output) => void): grpc.ClientWritableStream<_grpc_testing_StreamingInputCallResponse__Output>;
+  StreamingInputCall(metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_StreamingInputCallResponse__Output) => void): grpc.ClientWritableStream<_grpc_testing_StreamingInputCallResponse__Output>;
+  StreamingInputCall(options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_StreamingInputCallResponse__Output) => void): grpc.ClientWritableStream<_grpc_testing_StreamingInputCallResponse__Output>;
+  StreamingInputCall(callback: (error?: grpc.ServiceError, result?: _grpc_testing_StreamingInputCallResponse__Output) => void): grpc.ClientWritableStream<_grpc_testing_StreamingInputCallResponse__Output>;
+  /**
+   * A sequence of requests followed by one response (streamed upload).
+   * The server returns the aggregated size of client payload as the result.
+   */
+  streamingInputCall(metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_StreamingInputCallResponse__Output) => void): grpc.ClientWritableStream<_grpc_testing_StreamingInputCallResponse__Output>;
+  streamingInputCall(metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_StreamingInputCallResponse__Output) => void): grpc.ClientWritableStream<_grpc_testing_StreamingInputCallResponse__Output>;
+  streamingInputCall(options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_StreamingInputCallResponse__Output) => void): grpc.ClientWritableStream<_grpc_testing_StreamingInputCallResponse__Output>;
+  streamingInputCall(callback: (error?: grpc.ServiceError, result?: _grpc_testing_StreamingInputCallResponse__Output) => void): grpc.ClientWritableStream<_grpc_testing_StreamingInputCallResponse__Output>;
+  
+  /**
+   * One request followed by a sequence of responses (streamed download).
+   * The server returns the payload with client desired type and sizes.
+   */
+  StreamingOutputCall(argument: _grpc_testing_StreamingOutputCallRequest, metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<_grpc_testing_StreamingOutputCallResponse__Output>;
+  StreamingOutputCall(argument: _grpc_testing_StreamingOutputCallRequest, options?: grpc.CallOptions): grpc.ClientReadableStream<_grpc_testing_StreamingOutputCallResponse__Output>;
+  /**
+   * One request followed by a sequence of responses (streamed download).
+   * The server returns the payload with client desired type and sizes.
+   */
+  streamingOutputCall(argument: _grpc_testing_StreamingOutputCallRequest, metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<_grpc_testing_StreamingOutputCallResponse__Output>;
+  streamingOutputCall(argument: _grpc_testing_StreamingOutputCallRequest, options?: grpc.CallOptions): grpc.ClientReadableStream<_grpc_testing_StreamingOutputCallResponse__Output>;
+  
+  /**
+   * One request followed by one response.
+   */
+  UnaryCall(argument: _grpc_testing_SimpleRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  UnaryCall(argument: _grpc_testing_SimpleRequest, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  UnaryCall(argument: _grpc_testing_SimpleRequest, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  UnaryCall(argument: _grpc_testing_SimpleRequest, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  /**
+   * One request followed by one response.
+   */
+  unaryCall(argument: _grpc_testing_SimpleRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  unaryCall(argument: _grpc_testing_SimpleRequest, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  unaryCall(argument: _grpc_testing_SimpleRequest, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  unaryCall(argument: _grpc_testing_SimpleRequest, callback: (error?: grpc.ServiceError, result?: _grpc_testing_SimpleResponse__Output) => void): grpc.ClientUnaryCall;
+  
+  /**
+   * The test server will not implement this method. It will be used
+   * to test the behavior when clients call unimplemented methods.
+   */
+  UnimplementedCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  UnimplementedCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  UnimplementedCall(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  UnimplementedCall(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  /**
+   * The test server will not implement this method. It will be used
+   * to test the behavior when clients call unimplemented methods.
+   */
+  unimplementedCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  unimplementedCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  unimplementedCall(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  unimplementedCall(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  
+}
+
+/**
+ * A simple service to test the various types of RPCs and experiment with
+ * performance with various types of payload.
+ */
+export interface TestServiceHandlers extends grpc.UntypedServiceImplementation {
+  /**
+   * One request followed by one response. Response has cache control
+   * headers set such that a caching HTTP proxy (such as GFE) can
+   * satisfy subsequent requests.
+   */
+  CacheableUnaryCall(call: grpc.ServerUnaryCall<_grpc_testing_SimpleRequest__Output, _grpc_testing_SimpleResponse>, callback: grpc.sendUnaryData<_grpc_testing_SimpleResponse>): void;
+  
+  /**
+   * One empty request followed by one empty response.
+   */
+  EmptyCall(call: grpc.ServerUnaryCall<_grpc_testing_Empty__Output, _grpc_testing_Empty>, callback: grpc.sendUnaryData<_grpc_testing_Empty>): void;
+  
+  /**
+   * A sequence of requests with each request served by the server immediately.
+   * As one request could lead to multiple responses, this interface
+   * demonstrates the idea of full duplexing.
+   */
+  FullDuplexCall(call: grpc.ServerDuplexStream<_grpc_testing_StreamingOutputCallRequest__Output, _grpc_testing_StreamingOutputCallResponse>): void;
+  
+  /**
+   * A sequence of requests followed by a sequence of responses.
+   * The server buffers all the client requests and then serves them in order. A
+   * stream of responses are returned to the client when the server starts with
+   * first request.
+   */
+  HalfDuplexCall(call: grpc.ServerDuplexStream<_grpc_testing_StreamingOutputCallRequest__Output, _grpc_testing_StreamingOutputCallResponse>): void;
+  
+  /**
+   * A sequence of requests followed by one response (streamed upload).
+   * The server returns the aggregated size of client payload as the result.
+   */
+  StreamingInputCall(call: grpc.ServerReadableStream<_grpc_testing_StreamingInputCallRequest__Output, _grpc_testing_StreamingInputCallResponse>, callback: grpc.sendUnaryData<_grpc_testing_StreamingInputCallResponse>): void;
+  
+  /**
+   * One request followed by a sequence of responses (streamed download).
+   * The server returns the payload with client desired type and sizes.
+   */
+  StreamingOutputCall(call: grpc.ServerWritableStream<_grpc_testing_StreamingOutputCallRequest__Output, _grpc_testing_StreamingOutputCallResponse>): void;
+  
+  /**
+   * One request followed by one response.
+   */
+  UnaryCall(call: grpc.ServerUnaryCall<_grpc_testing_SimpleRequest__Output, _grpc_testing_SimpleResponse>, callback: grpc.sendUnaryData<_grpc_testing_SimpleResponse>): void;
+  
+  /**
+   * The test server will not implement this method. It will be used
+   * to test the behavior when clients call unimplemented methods.
+   */
+  UnimplementedCall(call: grpc.ServerUnaryCall<_grpc_testing_Empty__Output, _grpc_testing_Empty>, callback: grpc.sendUnaryData<_grpc_testing_Empty>): void;
+  
+}

packages/grpc-js/interop/generated/grpc/testing/UnimplementedService.ts

@@ -0,0 +1,38 @@
+// Original file: proto/grpc/testing/test.proto
+
+import * as grpc from '../../../../src'
+import { Empty as _grpc_testing_Empty, Empty__Output as _grpc_testing_Empty__Output } from '../../grpc/testing/Empty';
+
+/**
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ */
+export interface UnimplementedServiceClient extends grpc.Client {
+  /**
+   * A call that no server should implement
+   */
+  UnimplementedCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  UnimplementedCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  UnimplementedCall(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  UnimplementedCall(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  /**
+   * A call that no server should implement
+   */
+  unimplementedCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  unimplementedCall(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  unimplementedCall(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  unimplementedCall(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  
+}
+
+/**
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ */
+export interface UnimplementedServiceHandlers extends grpc.UntypedServiceImplementation {
+  /**
+   * A call that no server should implement
+   */
+  UnimplementedCall(call: grpc.ServerUnaryCall<_grpc_testing_Empty__Output, _grpc_testing_Empty>, callback: grpc.sendUnaryData<_grpc_testing_Empty>): void;
+  
+}

packages/grpc-js/interop/generated/grpc/testing/XdsUpdateHealthService.ts

@@ -0,0 +1,38 @@
+// Original file: proto/grpc/testing/test.proto
+
+import * as grpc from '../../../../src'
+import { Empty as _grpc_testing_Empty, Empty__Output as _grpc_testing_Empty__Output } from '../../grpc/testing/Empty';
+
+/**
+ * A service to remotely control health status of an xDS test server.
+ */
+export interface XdsUpdateHealthServiceClient extends grpc.Client {
+  SetNotServing(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  SetNotServing(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  SetNotServing(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  SetNotServing(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  setNotServing(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  setNotServing(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  setNotServing(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  setNotServing(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  
+  SetServing(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  SetServing(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  SetServing(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  SetServing(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  setServing(argument: _grpc_testing_Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  setServing(argument: _grpc_testing_Empty, metadata: grpc.Metadata, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  setServing(argument: _grpc_testing_Empty, options: grpc.CallOptions, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  setServing(argument: _grpc_testing_Empty, callback: (error?: grpc.ServiceError, result?: _grpc_testing_Empty__Output) => void): grpc.ClientUnaryCall;
+  
+}
+
+/**
+ * A service to remotely control health status of an xDS test server.
+ */
+export interface XdsUpdateHealthServiceHandlers extends grpc.UntypedServiceImplementation {
+  SetNotServing(call: grpc.ServerUnaryCall<_grpc_testing_Empty__Output, _grpc_testing_Empty>, callback: grpc.sendUnaryData<_grpc_testing_Empty>): void;
+  
+  SetServing(call: grpc.ServerUnaryCall<_grpc_testing_Empty__Output, _grpc_testing_Empty>, callback: grpc.sendUnaryData<_grpc_testing_Empty>): void;
+  
+}

packages/grpc-js/interop/generated/test.ts

@@ -0,0 +1,60 @@
+import * as grpc from '../../src';
+import { ServiceDefinition, EnumTypeDefinition, MessageTypeDefinition } from '@grpc/proto-loader';
+
+import { LoadBalancerStatsServiceClient as _grpc_testing_LoadBalancerStatsServiceClient } from './grpc/testing/LoadBalancerStatsService';
+import { ReconnectServiceClient as _grpc_testing_ReconnectServiceClient } from './grpc/testing/ReconnectService';
+import { TestServiceClient as _grpc_testing_TestServiceClient } from './grpc/testing/TestService';
+import { UnimplementedServiceClient as _grpc_testing_UnimplementedServiceClient } from './grpc/testing/UnimplementedService';
+import { XdsUpdateHealthServiceClient as _grpc_testing_XdsUpdateHealthServiceClient } from './grpc/testing/XdsUpdateHealthService';
+
+type ConstructorArguments<Constructor> = Constructor extends new (...args: infer Args) => any ? Args: never;
+type SubtypeConstructor<Constructor, Subtype> = {
+  new(...args: ConstructorArguments<Constructor>): Subtype;
+};
+
+export interface ProtoGrpcType {
+  grpc: {
+    testing: {
+      BoolValue: MessageTypeDefinition
+      EchoStatus: MessageTypeDefinition
+      Empty: MessageTypeDefinition
+      GrpclbRouteType: EnumTypeDefinition
+      LoadBalancerStatsRequest: MessageTypeDefinition
+      LoadBalancerStatsResponse: MessageTypeDefinition
+      /**
+       * A service used to obtain stats for verifying LB behavior.
+       */
+      LoadBalancerStatsService: SubtypeConstructor<typeof grpc.Client, _grpc_testing_LoadBalancerStatsServiceClient> & { service: ServiceDefinition }
+      Payload: MessageTypeDefinition
+      PayloadType: EnumTypeDefinition
+      ReconnectInfo: MessageTypeDefinition
+      ReconnectParams: MessageTypeDefinition
+      /**
+       * A service used to control reconnect server.
+       */
+      ReconnectService: SubtypeConstructor<typeof grpc.Client, _grpc_testing_ReconnectServiceClient> & { service: ServiceDefinition }
+      ResponseParameters: MessageTypeDefinition
+      SimpleRequest: MessageTypeDefinition
+      SimpleResponse: MessageTypeDefinition
+      StreamingInputCallRequest: MessageTypeDefinition
+      StreamingInputCallResponse: MessageTypeDefinition
+      StreamingOutputCallRequest: MessageTypeDefinition
+      StreamingOutputCallResponse: MessageTypeDefinition
+      /**
+       * A simple service to test the various types of RPCs and experiment with
+       * performance with various types of payload.
+       */
+      TestService: SubtypeConstructor<typeof grpc.Client, _grpc_testing_TestServiceClient> & { service: ServiceDefinition }
+      /**
+       * A simple service NOT implemented at servers so clients can test for
+       * that case.
+       */
+      UnimplementedService: SubtypeConstructor<typeof grpc.Client, _grpc_testing_UnimplementedServiceClient> & { service: ServiceDefinition }
+      /**
+       * A service to remotely control health status of an xDS test server.
+       */
+      XdsUpdateHealthService: SubtypeConstructor<typeof grpc.Client, _grpc_testing_XdsUpdateHealthServiceClient> & { service: ServiceDefinition }
+    }
+  }
+}
+

packages/grpc-js/interop/xds-interop-client.ts

@@ -0,0 +1,220 @@
+/*
+ * Copyright 2020 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import * as grpc from '../src';
+
+import { ProtoGrpcType } from './generated/test';
+
+import * as protoLoader from '@grpc/proto-loader';
+import { TestServiceClient } from './generated/grpc/testing/TestService';
+import { LoadBalancerStatsResponse } from './generated/grpc/testing/LoadBalancerStatsResponse';
+import * as yargs from 'yargs';
+import { LoadBalancerStatsServiceHandlers } from './generated/grpc/testing/LoadBalancerStatsService';
+
+const packageDefinition = protoLoader.loadSync('grpc/testing/test.proto', {
+  keepCase: true,
+  defaults: true,
+  oneofs: true,
+  json: true,
+  longs: String,
+  enums: String,
+  includeDirs: [__dirname + '/../../proto']
+});
+
+const loadedProto = grpc.loadPackageDefinition(packageDefinition) as unknown as ProtoGrpcType;
+
+interface CallEndNotifier {
+  onCallSucceeded(peerName: string): void;
+  onCallFailed(): void;
+}
+
+class CallSubscriber {
+  private callsStarted = 0;
+  private callsSucceededByPeer: {[key: string]: number} = {};
+  private callsSucceeded = 0;
+  private callsFinished = 0;
+
+  constructor(private callGoal: number, private onFinished: () => void) {}
+
+  addCallStarted(): void {
+    this.callsStarted += 1;
+  }
+
+  private maybeOnFinished() {
+    if (this.callsFinished == this.callGoal) {
+      this.onFinished();
+    }
+  }
+
+  addCallSucceeded(peerName: string): void {
+    if (peerName in this.callsSucceededByPeer) {
+      this.callsSucceededByPeer[peerName] += 1;
+    } else {    
+      this.callsSucceededByPeer[peerName] = 1;
+    }
+    this.callsSucceeded += 1;
+    this.callsFinished += 1;
+    this.maybeOnFinished();
+  }
+  addCallFailed(): void {
+    this.callsFinished += 1;
+    this.maybeOnFinished();
+  }
+
+  needsMoreCalls(): boolean {
+    return this.callsStarted < this.callGoal;
+  }
+
+  getFinalStats(): LoadBalancerStatsResponse {
+    return {
+      rpcs_by_peer: this.callsSucceededByPeer,
+      num_failures: this.callsStarted - this.callsSucceeded
+    };
+  }
+}
+
+class CallStatsTracker {
+
+  private subscribers: CallSubscriber[] = [];
+
+  getCallStats(callCount: number, timeoutSec: number): Promise<LoadBalancerStatsResponse> {
+    return new Promise((resolve, reject) => {
+      let finished = false;
+      const subscriber = new CallSubscriber(callCount, () => {
+        if (!finished) {
+          finished = true;
+          resolve(subscriber.getFinalStats());
+        }
+      });
+      setTimeout(() => {
+        if (!finished) {
+          finished = true;
+          this.subscribers.splice(this.subscribers.indexOf(subscriber), 1);
+          resolve(subscriber.getFinalStats());
+        }
+      }, timeoutSec * 1000)
+      this.subscribers.push(subscriber);
+    })
+  }
+
+  startCall(): CallEndNotifier {
+    const callSubscribers = this.subscribers.slice();
+    for (const subscriber of callSubscribers) {
+      subscriber.addCallStarted();
+      if (!subscriber.needsMoreCalls()) {
+        this.subscribers.splice(this.subscribers.indexOf(subscriber), 1);
+      }
+    }
+    return {
+      onCallSucceeded: (peerName: string) => {
+        for (const subscriber of callSubscribers) {
+          subscriber.addCallSucceeded(peerName);
+        }
+      },
+      onCallFailed: () => {
+        for (const subscriber of callSubscribers) {
+          subscriber.addCallFailed();
+        }
+      }
+    }
+  }
+}
+
+function sendConstantQps(client: TestServiceClient, qps: number, failOnFailedRpcs: boolean, callStatsTracker: CallStatsTracker) {
+  let anyCallSucceeded: boolean = false;
+  setInterval(() => {
+    const notifier = callStatsTracker.startCall();
+    let gotMetadata: boolean = false;
+    let hostname: string | null = null;
+    let completed: boolean = false;
+    let completedWithError: boolean = false;
+    const call = client.emptyCall({}, (error, value) => {
+      if (error) {
+        if (failOnFailedRpcs && anyCallSucceeded) {
+          console.error('A call failed after a call succeeded');
+          process.exit(1);
+        }
+        completed = true;
+        completedWithError = true;
+        notifier.onCallFailed();
+      } else {
+        anyCallSucceeded = true;
+        if (gotMetadata) {
+          if (hostname === null) {
+            notifier.onCallFailed()
+          } else {
+            notifier.onCallSucceeded(hostname);
+          }
+        }
+      }
+    });
+    call.on('metadata', (metadata) => {
+      hostname = (metadata.get('hostname') as string[])[0] ?? null;
+      gotMetadata = true;
+      if (completed && !completedWithError) {
+        if (hostname === null) {
+          notifier.onCallFailed();
+        } else {
+          notifier.onCallSucceeded(hostname);
+        }
+      }
+    })
+  }, 1000/qps);
+}
+
+
+
+function main() {
+  const argv = yargs
+    .string(['fail_on_failed_rpcs', 'server', 'stats_port'])
+    .number(['num_channels', 'qps'])
+    .require(['fail_on_failed_rpcs', 'num_channels', 'qps', 'server', 'stats_port'])
+    .argv;
+  const callStatsTracker = new CallStatsTracker();
+  for (let i = 0; i < argv.num_channels; i++) {
+    /* The 'unique' channel argument is there solely to ensure that the
+     * channels do not share any subchannels. It does not have any
+     * inherent function. */
+    sendConstantQps(new loadedProto.grpc.testing.TestService(argv.server, grpc.credentials.createInsecure(), {'unique': i}), 
+      argv.qps, 
+      argv.fail_on_failed_rpcs === 'true', 
+      callStatsTracker);
+  }
+
+  const loadBalancerStatsServiceImpl: LoadBalancerStatsServiceHandlers = {
+    GetClientStats: (call, callback) => {
+      callStatsTracker.getCallStats(call.request.num_rpcs, call.request.timeout_sec).then((value) => {
+        callback(null, value);
+      }, (error) => {
+        callback({code: grpc.status.ABORTED, details: 'Call stats collection failed'});
+      });
+    }
+  }
+
+  const server = new grpc.Server();
+  server.addService(loadedProto.grpc.testing.LoadBalancerStatsService.service, loadBalancerStatsServiceImpl);
+  server.bindAsync(`0.0.0.0:${argv.stats_port}`, grpc.ServerCredentials.createInsecure(), (error, port) => {
+    if (error) {
+      throw error;
+    }
+    server.start();
+  });
+}
+
+if (require.main === module) {
+  main();
+}