@kenji71089/evaluation 0.0.1

package/lib/proto/gateway/service_pb_service.d.ts

@@ -0,0 +1,253 @@
+// package: bucketeer.gateway
+// file: proto/gateway/service.proto
+
+import * as proto_gateway_service_pb from '../../proto/gateway/service_pb';
+import {grpc} from '@improbable-eng/grpc-web';
+
+type GatewayGetEvaluations = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.GetEvaluationsRequest;
+  readonly responseType: typeof proto_gateway_service_pb.GetEvaluationsResponse;
+};
+
+type GatewayGetEvaluation = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.GetEvaluationRequest;
+  readonly responseType: typeof proto_gateway_service_pb.GetEvaluationResponse;
+};
+
+type GatewayGetFeatureFlags = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.GetFeatureFlagsRequest;
+  readonly responseType: typeof proto_gateway_service_pb.GetFeatureFlagsResponse;
+};
+
+type GatewayGetSegmentUsers = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.GetSegmentUsersRequest;
+  readonly responseType: typeof proto_gateway_service_pb.GetSegmentUsersResponse;
+};
+
+type GatewayRegisterEvents = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.RegisterEventsRequest;
+  readonly responseType: typeof proto_gateway_service_pb.RegisterEventsResponse;
+};
+
+type GatewayTrack = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.TrackRequest;
+  readonly responseType: typeof proto_gateway_service_pb.TrackResponse;
+};
+
+type GatewayCreateFeature = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.CreateFeatureRequest;
+  readonly responseType: typeof proto_gateway_service_pb.CreateFeatureResponse;
+};
+
+type GatewayGetFeature = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.GetFeatureRequest;
+  readonly responseType: typeof proto_gateway_service_pb.GetFeatureResponse;
+};
+
+type GatewayListFeatures = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.ListFeaturesRequest;
+  readonly responseType: typeof proto_gateway_service_pb.ListFeaturesResponse;
+};
+
+type GatewayUpdateFeature = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.UpdateFeatureRequest;
+  readonly responseType: typeof proto_gateway_service_pb.UpdateFeatureResponse;
+};
+
+type GatewayPing = {
+  readonly methodName: string;
+  readonly service: typeof Gateway;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof proto_gateway_service_pb.PingRequest;
+  readonly responseType: typeof proto_gateway_service_pb.PingResponse;
+};
+
+export class Gateway {
+  static readonly serviceName: string;
+  static readonly GetEvaluations: GatewayGetEvaluations;
+  static readonly GetEvaluation: GatewayGetEvaluation;
+  static readonly GetFeatureFlags: GatewayGetFeatureFlags;
+  static readonly GetSegmentUsers: GatewayGetSegmentUsers;
+  static readonly RegisterEvents: GatewayRegisterEvents;
+  static readonly Track: GatewayTrack;
+  static readonly CreateFeature: GatewayCreateFeature;
+  static readonly GetFeature: GatewayGetFeature;
+  static readonly ListFeatures: GatewayListFeatures;
+  static readonly UpdateFeature: GatewayUpdateFeature;
+  static readonly Ping: GatewayPing;
+}
+
+export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
+export type Status = { details: string, code: number; metadata: grpc.Metadata }
+
+interface UnaryResponse {
+  cancel(): void;
+}
+interface ResponseStream<T> {
+  cancel(): void;
+  on(type: 'data', handler: (message: T) => void): ResponseStream<T>;
+  on(type: 'end', handler: (status?: Status) => void): ResponseStream<T>;
+  on(type: 'status', handler: (status: Status) => void): ResponseStream<T>;
+}
+interface RequestStream<T> {
+  write(message: T): RequestStream<T>;
+  end(): void;
+  cancel(): void;
+  on(type: 'end', handler: (status?: Status) => void): RequestStream<T>;
+  on(type: 'status', handler: (status: Status) => void): RequestStream<T>;
+}
+interface BidirectionalStream<ReqT, ResT> {
+  write(message: ReqT): BidirectionalStream<ReqT, ResT>;
+  end(): void;
+  cancel(): void;
+  on(type: 'data', handler: (message: ResT) => void): BidirectionalStream<ReqT, ResT>;
+  on(type: 'end', handler: (status?: Status) => void): BidirectionalStream<ReqT, ResT>;
+  on(type: 'status', handler: (status: Status) => void): BidirectionalStream<ReqT, ResT>;
+}
+
+export class GatewayClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  getEvaluations(
+    requestMessage: proto_gateway_service_pb.GetEvaluationsRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.GetEvaluationsResponse|null) => void
+  ): UnaryResponse;
+  getEvaluations(
+    requestMessage: proto_gateway_service_pb.GetEvaluationsRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.GetEvaluationsResponse|null) => void
+  ): UnaryResponse;
+  getEvaluation(
+    requestMessage: proto_gateway_service_pb.GetEvaluationRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.GetEvaluationResponse|null) => void
+  ): UnaryResponse;
+  getEvaluation(
+    requestMessage: proto_gateway_service_pb.GetEvaluationRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.GetEvaluationResponse|null) => void
+  ): UnaryResponse;
+  getFeatureFlags(
+    requestMessage: proto_gateway_service_pb.GetFeatureFlagsRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.GetFeatureFlagsResponse|null) => void
+  ): UnaryResponse;
+  getFeatureFlags(
+    requestMessage: proto_gateway_service_pb.GetFeatureFlagsRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.GetFeatureFlagsResponse|null) => void
+  ): UnaryResponse;
+  getSegmentUsers(
+    requestMessage: proto_gateway_service_pb.GetSegmentUsersRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.GetSegmentUsersResponse|null) => void
+  ): UnaryResponse;
+  getSegmentUsers(
+    requestMessage: proto_gateway_service_pb.GetSegmentUsersRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.GetSegmentUsersResponse|null) => void
+  ): UnaryResponse;
+  registerEvents(
+    requestMessage: proto_gateway_service_pb.RegisterEventsRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.RegisterEventsResponse|null) => void
+  ): UnaryResponse;
+  registerEvents(
+    requestMessage: proto_gateway_service_pb.RegisterEventsRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.RegisterEventsResponse|null) => void
+  ): UnaryResponse;
+  track(
+    requestMessage: proto_gateway_service_pb.TrackRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.TrackResponse|null) => void
+  ): UnaryResponse;
+  track(
+    requestMessage: proto_gateway_service_pb.TrackRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.TrackResponse|null) => void
+  ): UnaryResponse;
+  createFeature(
+    requestMessage: proto_gateway_service_pb.CreateFeatureRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.CreateFeatureResponse|null) => void
+  ): UnaryResponse;
+  createFeature(
+    requestMessage: proto_gateway_service_pb.CreateFeatureRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.CreateFeatureResponse|null) => void
+  ): UnaryResponse;
+  getFeature(
+    requestMessage: proto_gateway_service_pb.GetFeatureRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.GetFeatureResponse|null) => void
+  ): UnaryResponse;
+  getFeature(
+    requestMessage: proto_gateway_service_pb.GetFeatureRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.GetFeatureResponse|null) => void
+  ): UnaryResponse;
+  listFeatures(
+    requestMessage: proto_gateway_service_pb.ListFeaturesRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.ListFeaturesResponse|null) => void
+  ): UnaryResponse;
+  listFeatures(
+    requestMessage: proto_gateway_service_pb.ListFeaturesRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.ListFeaturesResponse|null) => void
+  ): UnaryResponse;
+  updateFeature(
+    requestMessage: proto_gateway_service_pb.UpdateFeatureRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.UpdateFeatureResponse|null) => void
+  ): UnaryResponse;
+  updateFeature(
+    requestMessage: proto_gateway_service_pb.UpdateFeatureRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.UpdateFeatureResponse|null) => void
+  ): UnaryResponse;
+  ping(
+    requestMessage: proto_gateway_service_pb.PingRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.PingResponse|null) => void
+  ): UnaryResponse;
+  ping(
+    requestMessage: proto_gateway_service_pb.PingRequest,
+    callback: (error: ServiceError|null, responseMessage: proto_gateway_service_pb.PingResponse|null) => void
+  ): UnaryResponse;
+}
+

package/lib/proto/gateway/service_pb_service.js

@@ -0,0 +1,436 @@
+"use strict";
+
+// package: bucketeer.gateway
+// file: proto/gateway/service.proto
+
+var proto_gateway_service_pb = require("../../proto/gateway/service_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+var Gateway = function () {
+  function Gateway() {}
+  Gateway.serviceName = "bucketeer.gateway.Gateway";
+  return Gateway;
+}();
+Gateway.GetEvaluations = {
+  methodName: "GetEvaluations",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.GetEvaluationsRequest,
+  responseType: proto_gateway_service_pb.GetEvaluationsResponse
+};
+Gateway.GetEvaluation = {
+  methodName: "GetEvaluation",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.GetEvaluationRequest,
+  responseType: proto_gateway_service_pb.GetEvaluationResponse
+};
+Gateway.GetFeatureFlags = {
+  methodName: "GetFeatureFlags",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.GetFeatureFlagsRequest,
+  responseType: proto_gateway_service_pb.GetFeatureFlagsResponse
+};
+Gateway.GetSegmentUsers = {
+  methodName: "GetSegmentUsers",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.GetSegmentUsersRequest,
+  responseType: proto_gateway_service_pb.GetSegmentUsersResponse
+};
+Gateway.RegisterEvents = {
+  methodName: "RegisterEvents",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.RegisterEventsRequest,
+  responseType: proto_gateway_service_pb.RegisterEventsResponse
+};
+Gateway.Track = {
+  methodName: "Track",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.TrackRequest,
+  responseType: proto_gateway_service_pb.TrackResponse
+};
+Gateway.CreateFeature = {
+  methodName: "CreateFeature",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.CreateFeatureRequest,
+  responseType: proto_gateway_service_pb.CreateFeatureResponse
+};
+Gateway.GetFeature = {
+  methodName: "GetFeature",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.GetFeatureRequest,
+  responseType: proto_gateway_service_pb.GetFeatureResponse
+};
+Gateway.ListFeatures = {
+  methodName: "ListFeatures",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.ListFeaturesRequest,
+  responseType: proto_gateway_service_pb.ListFeaturesResponse
+};
+Gateway.UpdateFeature = {
+  methodName: "UpdateFeature",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.UpdateFeatureRequest,
+  responseType: proto_gateway_service_pb.UpdateFeatureResponse
+};
+Gateway.Ping = {
+  methodName: "Ping",
+  service: Gateway,
+  requestStream: false,
+  responseStream: false,
+  requestType: proto_gateway_service_pb.PingRequest,
+  responseType: proto_gateway_service_pb.PingResponse
+};
+exports.Gateway = Gateway;
+function GatewayClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+GatewayClient.prototype.getEvaluations = function getEvaluations(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.GetEvaluations, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+GatewayClient.prototype.getEvaluation = function getEvaluation(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.GetEvaluation, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+GatewayClient.prototype.getFeatureFlags = function getFeatureFlags(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.GetFeatureFlags, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+GatewayClient.prototype.getSegmentUsers = function getSegmentUsers(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.GetSegmentUsers, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+GatewayClient.prototype.registerEvents = function registerEvents(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.RegisterEvents, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+GatewayClient.prototype.track = function track(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.Track, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+GatewayClient.prototype.createFeature = function createFeature(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.CreateFeature, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+GatewayClient.prototype.getFeature = function getFeature(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.GetFeature, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+GatewayClient.prototype.listFeatures = function listFeatures(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.ListFeatures, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+GatewayClient.prototype.updateFeature = function updateFeature(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.UpdateFeature, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+GatewayClient.prototype.ping = function ping(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(Gateway.Ping, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function onEnd(response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function cancel() {
+      callback = null;
+      client.close();
+    }
+  };
+};
+exports.GatewayClient = GatewayClient;