/**
 * @fileoverview gRPC-Web generated client stub for base
 * @enhanceable
 * @public
 */

// GENERATED CODE -- DO NOT EDIT!


/* eslint-disable */
// @ts-nocheck



const grpc = {};
grpc.web = require('grpc-web');

const proto = {};
proto.base = require('./base_pb.js');

/**
 * @param {string} hostname
 * @param {?Object} credentials
 * @param {?Object} options
 * @constructor
 * @struct
 * @final
 */
proto.base.ApiClient =
    function(hostname, credentials, options) {
  if (!options) options = {};
  options['format'] = 'text';

  /**
   * @private @const {!grpc.web.GrpcWebClientBase} The client
   */
  this.client_ = new grpc.web.GrpcWebClientBase(options);

  /**
   * @private @const {string} The hostname
   */
  this.hostname_ = hostname;

};


/**
 * @param {string} hostname
 * @param {?Object} credentials
 * @param {?Object} options
 * @constructor
 * @struct
 * @final
 */
proto.base.ApiPromiseClient =
    function(hostname, credentials, options) {
  if (!options) options = {};
  options['format'] = 'text';

  /**
   * @private @const {!grpc.web.GrpcWebClientBase} The client
   */
  this.client_ = new grpc.web.GrpcWebClientBase(options);

  /**
   * @private @const {string} The hostname
   */
  this.hostname_ = hostname;

};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.SignUpRequest,
 *   !proto.base.DefaultReply>}
 */
const methodDescriptor_Api_SignUp = new grpc.web.MethodDescriptor(
  '/base.Api/SignUp',
  grpc.web.MethodType.UNARY,
  proto.base.SignUpRequest,
  proto.base.DefaultReply,
  /**
   * @param {!proto.base.SignUpRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.DefaultReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.SignUpRequest,
 *   !proto.base.DefaultReply>}
 */
const methodInfo_Api_SignUp = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.DefaultReply,
  /**
   * @param {!proto.base.SignUpRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.DefaultReply.deserializeBinary
);


/**
 * @param {!proto.base.SignUpRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.DefaultReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.DefaultReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.signUp =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SignUp',
      request,
      metadata || {},
      methodDescriptor_Api_SignUp,
      callback);
};


/**
 * @param {!proto.base.SignUpRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.DefaultReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.signUp =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SignUp',
      request,
      metadata || {},
      methodDescriptor_Api_SignUp);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.SignInRequest,
 *   !proto.base.SignInReply>}
 */
const methodDescriptor_Api_SignIn = new grpc.web.MethodDescriptor(
  '/base.Api/SignIn',
  grpc.web.MethodType.UNARY,
  proto.base.SignInRequest,
  proto.base.SignInReply,
  /**
   * @param {!proto.base.SignInRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.SignInReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.SignInRequest,
 *   !proto.base.SignInReply>}
 */
const methodInfo_Api_SignIn = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.SignInReply,
  /**
   * @param {!proto.base.SignInRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.SignInReply.deserializeBinary
);


/**
 * @param {!proto.base.SignInRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.SignInReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.SignInReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.signIn =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SignIn',
      request,
      metadata || {},
      methodDescriptor_Api_SignIn,
      callback);
};


/**
 * @param {!proto.base.SignInRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.SignInReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.signIn =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SignIn',
      request,
      metadata || {},
      methodDescriptor_Api_SignIn);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.DefaultRequest,
 *   !proto.base.DefaultReply>}
 */
const methodDescriptor_Api_SignOut = new grpc.web.MethodDescriptor(
  '/base.Api/SignOut',
  grpc.web.MethodType.UNARY,
  proto.base.DefaultRequest,
  proto.base.DefaultReply,
  /**
   * @param {!proto.base.DefaultRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.DefaultReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.DefaultRequest,
 *   !proto.base.DefaultReply>}
 */
const methodInfo_Api_SignOut = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.DefaultReply,
  /**
   * @param {!proto.base.DefaultRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.DefaultReply.deserializeBinary
);


/**
 * @param {!proto.base.DefaultRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.DefaultReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.DefaultReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.signOut =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SignOut',
      request,
      metadata || {},
      methodDescriptor_Api_SignOut,
      callback);
};


/**
 * @param {!proto.base.DefaultRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.DefaultReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.signOut =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SignOut',
      request,
      metadata || {},
      methodDescriptor_Api_SignOut);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.GenVerifyImageRequest,
 *   !proto.base.GenVerifyImageReply>}
 */
const methodDescriptor_Api_GenVerifyImage = new grpc.web.MethodDescriptor(
  '/base.Api/GenVerifyImage',
  grpc.web.MethodType.UNARY,
  proto.base.GenVerifyImageRequest,
  proto.base.GenVerifyImageReply,
  /**
   * @param {!proto.base.GenVerifyImageRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.GenVerifyImageReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.GenVerifyImageRequest,
 *   !proto.base.GenVerifyImageReply>}
 */
const methodInfo_Api_GenVerifyImage = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.GenVerifyImageReply,
  /**
   * @param {!proto.base.GenVerifyImageRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.GenVerifyImageReply.deserializeBinary
);


/**
 * @param {!proto.base.GenVerifyImageRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.GenVerifyImageReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.GenVerifyImageReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.genVerifyImage =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/GenVerifyImage',
      request,
      metadata || {},
      methodDescriptor_Api_GenVerifyImage,
      callback);
};


/**
 * @param {!proto.base.GenVerifyImageRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.GenVerifyImageReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.genVerifyImage =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/GenVerifyImage',
      request,
      metadata || {},
      methodDescriptor_Api_GenVerifyImage);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SelectHrSensors = new grpc.web.MethodDescriptor(
  '/base.Api/SelectHrSensors',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SelectHrSensors = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.selectHrSensors =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SelectHrSensors',
      request,
      metadata || {},
      methodDescriptor_Api_SelectHrSensors,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.selectHrSensors =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SelectHrSensors',
      request,
      metadata || {},
      methodDescriptor_Api_SelectHrSensors);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_AcrossUserSimpleQuery = new grpc.web.MethodDescriptor(
  '/base.Api/AcrossUserSimpleQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_AcrossUserSimpleQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.acrossUserSimpleQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/AcrossUserSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_AcrossUserSimpleQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.acrossUserSimpleQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/AcrossUserSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_AcrossUserSimpleQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipUserSimpleQuery = new grpc.web.MethodDescriptor(
  '/base.Api/VipUserSimpleQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipUserSimpleQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipUserSimpleQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipUserSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipUserSimpleQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipUserSimpleQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipUserSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipUserSimpleQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_TempVipUserSimpleQuery = new grpc.web.MethodDescriptor(
  '/base.Api/TempVipUserSimpleQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_TempVipUserSimpleQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.tempVipUserSimpleQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/TempVipUserSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_TempVipUserSimpleQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.tempVipUserSimpleQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/TempVipUserSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_TempVipUserSimpleQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopSimpleQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ShopSimpleQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopSimpleQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopSimpleQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopSimpleQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopSimpleQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopSimpleQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ManageableSimpleQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ManageableSimpleQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ManageableSimpleQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.manageableSimpleQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ManageableSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ManageableSimpleQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.manageableSimpleQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ManageableSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ManageableSimpleQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassSimpleQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ClassSimpleQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassSimpleQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classSimpleQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ClassSimpleQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classSimpleQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ClassSimpleQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ScreenSimpleQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ScreenSimpleQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ScreenSimpleQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.screenSimpleQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ScreenSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ScreenSimpleQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.screenSimpleQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ScreenSimpleQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ScreenSimpleQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_GroupSimpleQueryByShopID = new grpc.web.MethodDescriptor(
  '/base.Api/GroupSimpleQueryByShopID',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_GroupSimpleQueryByShopID = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.groupSimpleQueryByShopID =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/GroupSimpleQueryByShopID',
      request,
      metadata || {},
      methodDescriptor_Api_GroupSimpleQueryByShopID,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.groupSimpleQueryByShopID =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/GroupSimpleQueryByShopID',
      request,
      metadata || {},
      methodDescriptor_Api_GroupSimpleQueryByShopID);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.ShopListRequest,
 *   !proto.base.ShopListReply>}
 */
const methodDescriptor_Api_ManageableShopList = new grpc.web.MethodDescriptor(
  '/base.Api/ManageableShopList',
  grpc.web.MethodType.UNARY,
  proto.base.ShopListRequest,
  proto.base.ShopListReply,
  /**
   * @param {!proto.base.ShopListRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.ShopListReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.ShopListRequest,
 *   !proto.base.ShopListReply>}
 */
const methodInfo_Api_ManageableShopList = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.ShopListReply,
  /**
   * @param {!proto.base.ShopListRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.ShopListReply.deserializeBinary
);


/**
 * @param {!proto.base.ShopListRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.ShopListReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.ShopListReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.manageableShopList =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ManageableShopList',
      request,
      metadata || {},
      methodDescriptor_Api_ManageableShopList,
      callback);
};


/**
 * @param {!proto.base.ShopListRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.ShopListReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.manageableShopList =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ManageableShopList',
      request,
      metadata || {},
      methodDescriptor_Api_ManageableShopList);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.ShopDetailRequest,
 *   !proto.base.ShopInfo>}
 */
const methodDescriptor_Api_ManageableGetShopInfo = new grpc.web.MethodDescriptor(
  '/base.Api/ManageableGetShopInfo',
  grpc.web.MethodType.UNARY,
  proto.base.ShopDetailRequest,
  proto.base.ShopInfo,
  /**
   * @param {!proto.base.ShopDetailRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.ShopInfo.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.ShopDetailRequest,
 *   !proto.base.ShopInfo>}
 */
const methodInfo_Api_ManageableGetShopInfo = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.ShopInfo,
  /**
   * @param {!proto.base.ShopDetailRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.ShopInfo.deserializeBinary
);


/**
 * @param {!proto.base.ShopDetailRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.ShopInfo)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.ShopInfo>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.manageableGetShopInfo =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ManageableGetShopInfo',
      request,
      metadata || {},
      methodDescriptor_Api_ManageableGetShopInfo,
      callback);
};


/**
 * @param {!proto.base.ShopDetailRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.ShopInfo>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.manageableGetShopInfo =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ManageableGetShopInfo',
      request,
      metadata || {},
      methodDescriptor_Api_ManageableGetShopInfo);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.ShopDetailRequest,
 *   !proto.base.LicenseList>}
 */
const methodDescriptor_Api_ShopLicenseList = new grpc.web.MethodDescriptor(
  '/base.Api/ShopLicenseList',
  grpc.web.MethodType.UNARY,
  proto.base.ShopDetailRequest,
  proto.base.LicenseList,
  /**
   * @param {!proto.base.ShopDetailRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.LicenseList.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.ShopDetailRequest,
 *   !proto.base.LicenseList>}
 */
const methodInfo_Api_ShopLicenseList = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.LicenseList,
  /**
   * @param {!proto.base.ShopDetailRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.LicenseList.deserializeBinary
);


/**
 * @param {!proto.base.ShopDetailRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.LicenseList)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.LicenseList>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopLicenseList =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopLicenseList',
      request,
      metadata || {},
      methodDescriptor_Api_ShopLicenseList,
      callback);
};


/**
 * @param {!proto.base.ShopDetailRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.LicenseList>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopLicenseList =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopLicenseList',
      request,
      metadata || {},
      methodDescriptor_Api_ShopLicenseList);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.IdList,
 *   !proto.base.LicenseTypeMapReply>}
 */
const methodDescriptor_Api_ShopLicenseTypeMap = new grpc.web.MethodDescriptor(
  '/base.Api/ShopLicenseTypeMap',
  grpc.web.MethodType.UNARY,
  proto.base.IdList,
  proto.base.LicenseTypeMapReply,
  /**
   * @param {!proto.base.IdList} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.LicenseTypeMapReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.IdList,
 *   !proto.base.LicenseTypeMapReply>}
 */
const methodInfo_Api_ShopLicenseTypeMap = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.LicenseTypeMapReply,
  /**
   * @param {!proto.base.IdList} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.LicenseTypeMapReply.deserializeBinary
);


/**
 * @param {!proto.base.IdList} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.LicenseTypeMapReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.LicenseTypeMapReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopLicenseTypeMap =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopLicenseTypeMap',
      request,
      metadata || {},
      methodDescriptor_Api_ShopLicenseTypeMap,
      callback);
};


/**
 * @param {!proto.base.IdList} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.LicenseTypeMapReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopLicenseTypeMap =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopLicenseTypeMap',
      request,
      metadata || {},
      methodDescriptor_Api_ShopLicenseTypeMap);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.GetShopNaviRequest,
 *   !proto.base.GetShopNaviReply>}
 */
const methodDescriptor_Api_GetShopNavi = new grpc.web.MethodDescriptor(
  '/base.Api/GetShopNavi',
  grpc.web.MethodType.UNARY,
  proto.base.GetShopNaviRequest,
  proto.base.GetShopNaviReply,
  /**
   * @param {!proto.base.GetShopNaviRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.GetShopNaviReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.GetShopNaviRequest,
 *   !proto.base.GetShopNaviReply>}
 */
const methodInfo_Api_GetShopNavi = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.GetShopNaviReply,
  /**
   * @param {!proto.base.GetShopNaviRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.GetShopNaviReply.deserializeBinary
);


/**
 * @param {!proto.base.GetShopNaviRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.GetShopNaviReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.GetShopNaviReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.getShopNavi =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/GetShopNavi',
      request,
      metadata || {},
      methodDescriptor_Api_GetShopNavi,
      callback);
};


/**
 * @param {!proto.base.GetShopNaviRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.GetShopNaviReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.getShopNavi =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/GetShopNavi',
      request,
      metadata || {},
      methodDescriptor_Api_GetShopNavi);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.GetShopNaviAllRequest,
 *   !proto.base.GetShopNaviAllReply>}
 */
const methodDescriptor_Api_GetShopNaviAll = new grpc.web.MethodDescriptor(
  '/base.Api/GetShopNaviAll',
  grpc.web.MethodType.UNARY,
  proto.base.GetShopNaviAllRequest,
  proto.base.GetShopNaviAllReply,
  /**
   * @param {!proto.base.GetShopNaviAllRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.GetShopNaviAllReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.GetShopNaviAllRequest,
 *   !proto.base.GetShopNaviAllReply>}
 */
const methodInfo_Api_GetShopNaviAll = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.GetShopNaviAllReply,
  /**
   * @param {!proto.base.GetShopNaviAllRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.GetShopNaviAllReply.deserializeBinary
);


/**
 * @param {!proto.base.GetShopNaviAllRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.GetShopNaviAllReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.GetShopNaviAllReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.getShopNaviAll =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/GetShopNaviAll',
      request,
      metadata || {},
      methodDescriptor_Api_GetShopNaviAll,
      callback);
};


/**
 * @param {!proto.base.GetShopNaviAllRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.GetShopNaviAllReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.getShopNaviAll =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/GetShopNaviAll',
      request,
      metadata || {},
      methodDescriptor_Api_GetShopNaviAll);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopGroupQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ShopGroupQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopGroupQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopGroupQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopGroupQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopGroupQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopGroupQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopGroupAdd = new grpc.web.MethodDescriptor(
  '/base.Api/ShopGroupAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopGroupAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopGroupAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopGroupAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopGroupAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopGroupAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopGroupEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopGroupEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopGroupEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopGroupEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopGroupEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopGroupEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopGroupEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopGroupStatusEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopGroupStatusEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopGroupStatusEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopGroupStatusEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopGroupStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupStatusEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopGroupStatusEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopGroupStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupStatusEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopGroupDetailsQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ShopGroupDetailsQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopGroupDetailsQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopGroupDetailsQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopGroupDetailsQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupDetailsQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopGroupDetailsQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopGroupDetailsQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupDetailsQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopGroupDetailsAdd = new grpc.web.MethodDescriptor(
  '/base.Api/ShopGroupDetailsAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopGroupDetailsAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopGroupDetailsAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopGroupDetailsAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupDetailsAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopGroupDetailsAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopGroupDetailsAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopGroupDetailsAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVenueQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVenueQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVenueQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVenueQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVenueQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVenueQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVenueQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVenueAdd = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVenueAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVenueAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVenueAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVenueAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVenueAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVenueAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVenueEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVenueEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVenueEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVenueEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVenueEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVenueEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVenueEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVenueStatusEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVenueStatusEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVenueStatusEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVenueStatusEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVenueStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueStatusEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVenueStatusEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVenueStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueStatusEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVenueEquipQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVenueEquipQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVenueEquipQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVenueEquipQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVenueEquipQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEquipQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVenueEquipQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVenueEquipQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEquipQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVenueEquipAdd = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVenueEquipAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVenueEquipAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVenueEquipAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVenueEquipAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEquipAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVenueEquipAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVenueEquipAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEquipAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVenueEquipEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVenueEquipEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVenueEquipEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVenueEquipEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVenueEquipEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEquipEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVenueEquipEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVenueEquipEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEquipEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVenueEquipStatusEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVenueEquipStatusEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVenueEquipStatusEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVenueEquipStatusEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVenueEquipStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEquipStatusEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVenueEquipStatusEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVenueEquipStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEquipStatusEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVenueEquipStatusDel = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVenueEquipStatusDel',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVenueEquipStatusDel = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVenueEquipStatusDel =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVenueEquipStatusDel',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEquipStatusDel,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVenueEquipStatusDel =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVenueEquipStatusDel',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVenueEquipStatusDel);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopManagerQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ShopManagerQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopManagerQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopManagerQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopManagerQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopManagerQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopManagerQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopManagerQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopManagerQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopManagerAdd = new grpc.web.MethodDescriptor(
  '/base.Api/ShopManagerAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopManagerAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopManagerAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopManagerAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopManagerAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopManagerAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopManagerAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopManagerAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopManagerEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopManagerEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopManagerEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopManagerEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopManagerEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopManagerEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopManagerEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopManagerEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopManagerEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopManagerStatusEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopManagerStatusEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopManagerStatusEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopManagerStatusEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopManagerStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopManagerStatusEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopManagerStatusEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopManagerStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopManagerStatusEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopConfigQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ShopConfigQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopConfigQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopConfigQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopConfigQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopConfigQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopConfigQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopConfigQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopConfigQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopConfigEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopConfigEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopConfigEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopConfigEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopConfigEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopConfigEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopConfigEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopConfigEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopConfigEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVipUserQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVipUserQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVipUserQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVipUserQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVipUserQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVipUserQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVipUserQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVipUserQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVipUserQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVipUserAdd = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVipUserAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVipUserAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVipUserAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVipUserAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVipUserAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVipUserAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVipUserAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVipUserAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVipUserEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVipUserEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVipUserEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVipUserEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVipUserEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVipUserEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVipUserEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVipUserEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVipUserEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ShopVipUserStatusEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ShopVipUserStatusEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ShopVipUserStatusEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.shopVipUserStatusEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ShopVipUserStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVipUserStatusEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.shopVipUserStatusEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ShopVipUserStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ShopVipUserStatusEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_AcrossVipUserQuery = new grpc.web.MethodDescriptor(
  '/base.Api/AcrossVipUserQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_AcrossVipUserQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.acrossVipUserQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/AcrossVipUserQuery',
      request,
      metadata || {},
      methodDescriptor_Api_AcrossVipUserQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.acrossVipUserQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/AcrossVipUserQuery',
      request,
      metadata || {},
      methodDescriptor_Api_AcrossVipUserQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_AcrossVipUserAdd = new grpc.web.MethodDescriptor(
  '/base.Api/AcrossVipUserAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_AcrossVipUserAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.acrossVipUserAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/AcrossVipUserAdd',
      request,
      metadata || {},
      methodDescriptor_Api_AcrossVipUserAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.acrossVipUserAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/AcrossVipUserAdd',
      request,
      metadata || {},
      methodDescriptor_Api_AcrossVipUserAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_AcrossVipUserDel = new grpc.web.MethodDescriptor(
  '/base.Api/AcrossVipUserDel',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_AcrossVipUserDel = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.acrossVipUserDel =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/AcrossVipUserDel',
      request,
      metadata || {},
      methodDescriptor_Api_AcrossVipUserDel,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.acrossVipUserDel =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/AcrossVipUserDel',
      request,
      metadata || {},
      methodDescriptor_Api_AcrossVipUserDel);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipPhoneQuery = new grpc.web.MethodDescriptor(
  '/base.Api/VipPhoneQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipPhoneQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipPhoneQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipPhoneQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipPhoneQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipPhoneQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipPhoneQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipPhoneQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipMainPhoneCheck = new grpc.web.MethodDescriptor(
  '/base.Api/VipMainPhoneCheck',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipMainPhoneCheck = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipMainPhoneCheck =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipMainPhoneCheck',
      request,
      metadata || {},
      methodDescriptor_Api_VipMainPhoneCheck,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipMainPhoneCheck =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipMainPhoneCheck',
      request,
      metadata || {},
      methodDescriptor_Api_VipMainPhoneCheck);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipOtherPhoneAdd = new grpc.web.MethodDescriptor(
  '/base.Api/VipOtherPhoneAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipOtherPhoneAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipOtherPhoneAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipOtherPhoneAdd',
      request,
      metadata || {},
      methodDescriptor_Api_VipOtherPhoneAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipOtherPhoneAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipOtherPhoneAdd',
      request,
      metadata || {},
      methodDescriptor_Api_VipOtherPhoneAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipOtherPhoneEdit = new grpc.web.MethodDescriptor(
  '/base.Api/VipOtherPhoneEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipOtherPhoneEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipOtherPhoneEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipOtherPhoneEdit',
      request,
      metadata || {},
      methodDescriptor_Api_VipOtherPhoneEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipOtherPhoneEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipOtherPhoneEdit',
      request,
      metadata || {},
      methodDescriptor_Api_VipOtherPhoneEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipOtherPhoneStatusEdit = new grpc.web.MethodDescriptor(
  '/base.Api/VipOtherPhoneStatusEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipOtherPhoneStatusEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipOtherPhoneStatusEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipOtherPhoneStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_VipOtherPhoneStatusEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipOtherPhoneStatusEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipOtherPhoneStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_VipOtherPhoneStatusEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_TempVipUserQuery = new grpc.web.MethodDescriptor(
  '/base.Api/TempVipUserQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_TempVipUserQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.tempVipUserQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/TempVipUserQuery',
      request,
      metadata || {},
      methodDescriptor_Api_TempVipUserQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.tempVipUserQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/TempVipUserQuery',
      request,
      metadata || {},
      methodDescriptor_Api_TempVipUserQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_TempVipUserAdd = new grpc.web.MethodDescriptor(
  '/base.Api/TempVipUserAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_TempVipUserAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.tempVipUserAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/TempVipUserAdd',
      request,
      metadata || {},
      methodDescriptor_Api_TempVipUserAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.tempVipUserAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/TempVipUserAdd',
      request,
      metadata || {},
      methodDescriptor_Api_TempVipUserAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_TempVipUserEdit = new grpc.web.MethodDescriptor(
  '/base.Api/TempVipUserEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_TempVipUserEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.tempVipUserEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/TempVipUserEdit',
      request,
      metadata || {},
      methodDescriptor_Api_TempVipUserEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.tempVipUserEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/TempVipUserEdit',
      request,
      metadata || {},
      methodDescriptor_Api_TempVipUserEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_TempVipUserStatusEdit = new grpc.web.MethodDescriptor(
  '/base.Api/TempVipUserStatusEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_TempVipUserStatusEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.tempVipUserStatusEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/TempVipUserStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_TempVipUserStatusEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.tempVipUserStatusEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/TempVipUserStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_TempVipUserStatusEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipHourEdit = new grpc.web.MethodDescriptor(
  '/base.Api/VipHourEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipHourEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipHourEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipHourEdit',
      request,
      metadata || {},
      methodDescriptor_Api_VipHourEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipHourEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipHourEdit',
      request,
      metadata || {},
      methodDescriptor_Api_VipHourEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipConsumeListQuery = new grpc.web.MethodDescriptor(
  '/base.Api/VipConsumeListQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipConsumeListQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipConsumeListQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipConsumeListQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipConsumeListQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipConsumeListQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipConsumeListQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipConsumeListQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipConsumeDetailQuery = new grpc.web.MethodDescriptor(
  '/base.Api/VipConsumeDetailQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipConsumeDetailQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipConsumeDetailQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipConsumeDetailQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipConsumeDetailQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipConsumeDetailQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipConsumeDetailQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipConsumeDetailQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipClassRelationEdit = new grpc.web.MethodDescriptor(
  '/base.Api/VipClassRelationEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipClassRelationEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipClassRelationEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipClassRelationEdit',
      request,
      metadata || {},
      methodDescriptor_Api_VipClassRelationEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipClassRelationEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipClassRelationEdit',
      request,
      metadata || {},
      methodDescriptor_Api_VipClassRelationEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipHourChgQuery = new grpc.web.MethodDescriptor(
  '/base.Api/VipHourChgQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipHourChgQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipHourChgQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipHourChgQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipHourChgQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipHourChgQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipHourChgQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipHourChgQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipUserClassQuery = new grpc.web.MethodDescriptor(
  '/base.Api/VipUserClassQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipUserClassQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipUserClassQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipUserClassQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipUserClassQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipUserClassQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipUserClassQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipUserClassQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.GetOverlayImgRequest,
 *   !proto.base.QiNiuTokenReply>}
 */
const methodDescriptor_Api_GetOverlayImgQiNiuToken = new grpc.web.MethodDescriptor(
  '/base.Api/GetOverlayImgQiNiuToken',
  grpc.web.MethodType.UNARY,
  proto.base.GetOverlayImgRequest,
  proto.base.QiNiuTokenReply,
  /**
   * @param {!proto.base.GetOverlayImgRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.QiNiuTokenReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.GetOverlayImgRequest,
 *   !proto.base.QiNiuTokenReply>}
 */
const methodInfo_Api_GetOverlayImgQiNiuToken = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.QiNiuTokenReply,
  /**
   * @param {!proto.base.GetOverlayImgRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.QiNiuTokenReply.deserializeBinary
);


/**
 * @param {!proto.base.GetOverlayImgRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.QiNiuTokenReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.QiNiuTokenReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.getOverlayImgQiNiuToken =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/GetOverlayImgQiNiuToken',
      request,
      metadata || {},
      methodDescriptor_Api_GetOverlayImgQiNiuToken,
      callback);
};


/**
 * @param {!proto.base.GetOverlayImgRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.QiNiuTokenReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.getOverlayImgQiNiuToken =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/GetOverlayImgQiNiuToken',
      request,
      metadata || {},
      methodDescriptor_Api_GetOverlayImgQiNiuToken);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.DefaultRequest,
 *   !proto.base.QiNiuTokenReply>}
 */
const methodDescriptor_Api_GetSimpleQiNiuToken = new grpc.web.MethodDescriptor(
  '/base.Api/GetSimpleQiNiuToken',
  grpc.web.MethodType.UNARY,
  proto.base.DefaultRequest,
  proto.base.QiNiuTokenReply,
  /**
   * @param {!proto.base.DefaultRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.QiNiuTokenReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.DefaultRequest,
 *   !proto.base.QiNiuTokenReply>}
 */
const methodInfo_Api_GetSimpleQiNiuToken = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.QiNiuTokenReply,
  /**
   * @param {!proto.base.DefaultRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.QiNiuTokenReply.deserializeBinary
);


/**
 * @param {!proto.base.DefaultRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.QiNiuTokenReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.QiNiuTokenReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.getSimpleQiNiuToken =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/GetSimpleQiNiuToken',
      request,
      metadata || {},
      methodDescriptor_Api_GetSimpleQiNiuToken,
      callback);
};


/**
 * @param {!proto.base.DefaultRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.QiNiuTokenReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.getSimpleQiNiuToken =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/GetSimpleQiNiuToken',
      request,
      metadata || {},
      methodDescriptor_Api_GetSimpleQiNiuToken);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ClassQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ClassQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ClassQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassAdd = new grpc.web.MethodDescriptor(
  '/base.Api/ClassAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ClassAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassAdd',
      request,
      metadata || {},
      methodDescriptor_Api_ClassAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ClassEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ClassEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ClassEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassStatusEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ClassStatusEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassStatusEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classStatusEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ClassStatusEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classStatusEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ClassStatusEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassColorEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ClassColorEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassColorEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classColorEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassColorEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ClassColorEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classColorEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassColorEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ClassColorEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassWxVisibleEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ClassWxVisibleEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassWxVisibleEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classWxVisibleEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassWxVisibleEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ClassWxVisibleEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classWxVisibleEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassWxVisibleEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ClassWxVisibleEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassVipEdit = new grpc.web.MethodDescriptor(
  '/base.Api/ClassVipEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassVipEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classVipEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassVipEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ClassVipEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classVipEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassVipEdit',
      request,
      metadata || {},
      methodDescriptor_Api_ClassVipEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SttPlanBasicQuery = new grpc.web.MethodDescriptor(
  '/base.Api/SttPlanBasicQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SttPlanBasicQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sttPlanBasicQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SttPlanBasicQuery',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sttPlanBasicQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SttPlanBasicQuery',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SttPlanBasicAdd = new grpc.web.MethodDescriptor(
  '/base.Api/SttPlanBasicAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SttPlanBasicAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sttPlanBasicAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SttPlanBasicAdd',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sttPlanBasicAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SttPlanBasicAdd',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SttPlanBasicEdit = new grpc.web.MethodDescriptor(
  '/base.Api/SttPlanBasicEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SttPlanBasicEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sttPlanBasicEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SttPlanBasicEdit',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sttPlanBasicEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SttPlanBasicEdit',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SttPlanBasicShopEdit = new grpc.web.MethodDescriptor(
  '/base.Api/SttPlanBasicShopEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SttPlanBasicShopEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sttPlanBasicShopEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SttPlanBasicShopEdit',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicShopEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sttPlanBasicShopEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SttPlanBasicShopEdit',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicShopEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SttPlanBasicStatusEdit = new grpc.web.MethodDescriptor(
  '/base.Api/SttPlanBasicStatusEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SttPlanBasicStatusEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sttPlanBasicStatusEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SttPlanBasicStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicStatusEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sttPlanBasicStatusEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SttPlanBasicStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicStatusEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SttPlanBasicPublish = new grpc.web.MethodDescriptor(
  '/base.Api/SttPlanBasicPublish',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SttPlanBasicPublish = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sttPlanBasicPublish =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SttPlanBasicPublish',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicPublish,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sttPlanBasicPublish =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SttPlanBasicPublish',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanBasicPublish);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SttPlanPreview = new grpc.web.MethodDescriptor(
  '/base.Api/SttPlanPreview',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SttPlanPreview = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sttPlanPreview =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SttPlanPreview',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanPreview,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sttPlanPreview =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SttPlanPreview',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanPreview);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SttPlanCopy = new grpc.web.MethodDescriptor(
  '/base.Api/SttPlanCopy',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SttPlanCopy = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sttPlanCopy =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SttPlanCopy',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanCopy,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sttPlanCopy =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SttPlanCopy',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanCopy);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SttPlanDetailQuery = new grpc.web.MethodDescriptor(
  '/base.Api/SttPlanDetailQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SttPlanDetailQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sttPlanDetailQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SttPlanDetailQuery',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanDetailQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sttPlanDetailQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SttPlanDetailQuery',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanDetailQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_SttPlanDetailBatchSave = new grpc.web.MethodDescriptor(
  '/base.Api/SttPlanDetailBatchSave',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_SttPlanDetailBatchSave = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sttPlanDetailBatchSave =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/SttPlanDetailBatchSave',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanDetailBatchSave,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sttPlanDetailBatchSave =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/SttPlanDetailBatchSave',
      request,
      metadata || {},
      methodDescriptor_Api_SttPlanDetailBatchSave);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_STTBasicQuery = new grpc.web.MethodDescriptor(
  '/base.Api/STTBasicQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_STTBasicQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sTTBasicQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/STTBasicQuery',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sTTBasicQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/STTBasicQuery',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_STTBasicAdd = new grpc.web.MethodDescriptor(
  '/base.Api/STTBasicAdd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_STTBasicAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sTTBasicAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/STTBasicAdd',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicAdd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sTTBasicAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/STTBasicAdd',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_STTBasicEdit = new grpc.web.MethodDescriptor(
  '/base.Api/STTBasicEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_STTBasicEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sTTBasicEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/STTBasicEdit',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sTTBasicEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/STTBasicEdit',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_STTBasicStatusEdit = new grpc.web.MethodDescriptor(
  '/base.Api/STTBasicStatusEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_STTBasicStatusEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sTTBasicStatusEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/STTBasicStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicStatusEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sTTBasicStatusEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/STTBasicStatusEdit',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicStatusEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_STTBasicPreview = new grpc.web.MethodDescriptor(
  '/base.Api/STTBasicPreview',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_STTBasicPreview = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sTTBasicPreview =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/STTBasicPreview',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicPreview,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sTTBasicPreview =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/STTBasicPreview',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicPreview);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_STTBasicCopy = new grpc.web.MethodDescriptor(
  '/base.Api/STTBasicCopy',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_STTBasicCopy = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sTTBasicCopy =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/STTBasicCopy',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicCopy,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sTTBasicCopy =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/STTBasicCopy',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicCopy);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_STTBasicOfflineEdit = new grpc.web.MethodDescriptor(
  '/base.Api/STTBasicOfflineEdit',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_STTBasicOfflineEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sTTBasicOfflineEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/STTBasicOfflineEdit',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicOfflineEdit,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sTTBasicOfflineEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/STTBasicOfflineEdit',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicOfflineEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_STTDetailListQuery = new grpc.web.MethodDescriptor(
  '/base.Api/STTDetailListQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_STTDetailListQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sTTDetailListQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/STTDetailListQuery',
      request,
      metadata || {},
      methodDescriptor_Api_STTDetailListQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sTTDetailListQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/STTDetailListQuery',
      request,
      metadata || {},
      methodDescriptor_Api_STTDetailListQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_STTBasicDetailBatchSave = new grpc.web.MethodDescriptor(
  '/base.Api/STTBasicDetailBatchSave',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_STTBasicDetailBatchSave = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sTTBasicDetailBatchSave =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/STTBasicDetailBatchSave',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicDetailBatchSave,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sTTBasicDetailBatchSave =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/STTBasicDetailBatchSave',
      request,
      metadata || {},
      methodDescriptor_Api_STTBasicDetailBatchSave);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_STTDetailAllowDelCheck = new grpc.web.MethodDescriptor(
  '/base.Api/STTDetailAllowDelCheck',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_STTDetailAllowDelCheck = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.sTTDetailAllowDelCheck =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/STTDetailAllowDelCheck',
      request,
      metadata || {},
      methodDescriptor_Api_STTDetailAllowDelCheck,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.sTTDetailAllowDelCheck =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/STTDetailAllowDelCheck',
      request,
      metadata || {},
      methodDescriptor_Api_STTDetailAllowDelCheck);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_CourseDetailQuery = new grpc.web.MethodDescriptor(
  '/base.Api/CourseDetailQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_CourseDetailQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.courseDetailQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/CourseDetailQuery',
      request,
      metadata || {},
      methodDescriptor_Api_CourseDetailQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.courseDetailQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/CourseDetailQuery',
      request,
      metadata || {},
      methodDescriptor_Api_CourseDetailQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassListByOrderDate = new grpc.web.MethodDescriptor(
  '/base.Api/ClassListByOrderDate',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassListByOrderDate = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classListByOrderDate =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassListByOrderDate',
      request,
      metadata || {},
      methodDescriptor_Api_ClassListByOrderDate,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classListByOrderDate =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassListByOrderDate',
      request,
      metadata || {},
      methodDescriptor_Api_ClassListByOrderDate);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassStartPrepare = new grpc.web.MethodDescriptor(
  '/base.Api/ClassStartPrepare',
  grpc.web.MethodType.UNARY,
  proto.base.CourseStandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassStartPrepare = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classStartPrepare =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassStartPrepare',
      request,
      metadata || {},
      methodDescriptor_Api_ClassStartPrepare,
      callback);
};


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classStartPrepare =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassStartPrepare',
      request,
      metadata || {},
      methodDescriptor_Api_ClassStartPrepare);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipClassDetailQuery = new grpc.web.MethodDescriptor(
  '/base.Api/VipClassDetailQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipClassDetailQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipClassDetailQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipClassDetailQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipClassDetailQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipClassDetailQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipClassDetailQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipClassDetailQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipClassDetailAdd = new grpc.web.MethodDescriptor(
  '/base.Api/VipClassDetailAdd',
  grpc.web.MethodType.UNARY,
  proto.base.CourseStandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipClassDetailAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipClassDetailAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipClassDetailAdd',
      request,
      metadata || {},
      methodDescriptor_Api_VipClassDetailAdd,
      callback);
};


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipClassDetailAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipClassDetailAdd',
      request,
      metadata || {},
      methodDescriptor_Api_VipClassDetailAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipClassDetailDel = new grpc.web.MethodDescriptor(
  '/base.Api/VipClassDetailDel',
  grpc.web.MethodType.UNARY,
  proto.base.CourseStandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipClassDetailDel = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipClassDetailDel =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipClassDetailDel',
      request,
      metadata || {},
      methodDescriptor_Api_VipClassDetailDel,
      callback);
};


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipClassDetailDel =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipClassDetailDel',
      request,
      metadata || {},
      methodDescriptor_Api_VipClassDetailDel);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_TmpClassDetailAdd = new grpc.web.MethodDescriptor(
  '/base.Api/TmpClassDetailAdd',
  grpc.web.MethodType.UNARY,
  proto.base.CourseStandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_TmpClassDetailAdd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.tmpClassDetailAdd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/TmpClassDetailAdd',
      request,
      metadata || {},
      methodDescriptor_Api_TmpClassDetailAdd,
      callback);
};


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.tmpClassDetailAdd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/TmpClassDetailAdd',
      request,
      metadata || {},
      methodDescriptor_Api_TmpClassDetailAdd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_TmpClassDetailDel = new grpc.web.MethodDescriptor(
  '/base.Api/TmpClassDetailDel',
  grpc.web.MethodType.UNARY,
  proto.base.CourseStandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_TmpClassDetailDel = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.tmpClassDetailDel =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/TmpClassDetailDel',
      request,
      metadata || {},
      methodDescriptor_Api_TmpClassDetailDel,
      callback);
};


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.tmpClassDetailDel =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/TmpClassDetailDel',
      request,
      metadata || {},
      methodDescriptor_Api_TmpClassDetailDel);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipClassDetailStatueEdit = new grpc.web.MethodDescriptor(
  '/base.Api/VipClassDetailStatueEdit',
  grpc.web.MethodType.UNARY,
  proto.base.CourseStandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipClassDetailStatueEdit = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipClassDetailStatueEdit =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipClassDetailStatueEdit',
      request,
      metadata || {},
      methodDescriptor_Api_VipClassDetailStatueEdit,
      callback);
};


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipClassDetailStatueEdit =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipClassDetailStatueEdit',
      request,
      metadata || {},
      methodDescriptor_Api_VipClassDetailStatueEdit);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassStartConfirm = new grpc.web.MethodDescriptor(
  '/base.Api/ClassStartConfirm',
  grpc.web.MethodType.UNARY,
  proto.base.CourseStandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassStartConfirm = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classStartConfirm =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassStartConfirm',
      request,
      metadata || {},
      methodDescriptor_Api_ClassStartConfirm,
      callback);
};


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classStartConfirm =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassStartConfirm',
      request,
      metadata || {},
      methodDescriptor_Api_ClassStartConfirm);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassOverConfirm = new grpc.web.MethodDescriptor(
  '/base.Api/ClassOverConfirm',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassOverConfirm = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classOverConfirm =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassOverConfirm',
      request,
      metadata || {},
      methodDescriptor_Api_ClassOverConfirm,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classOverConfirm =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassOverConfirm',
      request,
      metadata || {},
      methodDescriptor_Api_ClassOverConfirm);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassGiveUpConfirm = new grpc.web.MethodDescriptor(
  '/base.Api/ClassGiveUpConfirm',
  grpc.web.MethodType.UNARY,
  proto.base.CourseStandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassGiveUpConfirm = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classGiveUpConfirm =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassGiveUpConfirm',
      request,
      metadata || {},
      methodDescriptor_Api_ClassGiveUpConfirm,
      callback);
};


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classGiveUpConfirm =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassGiveUpConfirm',
      request,
      metadata || {},
      methodDescriptor_Api_ClassGiveUpConfirm);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_AfterClassAddClassDetail = new grpc.web.MethodDescriptor(
  '/base.Api/AfterClassAddClassDetail',
  grpc.web.MethodType.UNARY,
  proto.base.CourseStandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.CourseStandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_AfterClassAddClassDetail = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.CourseStandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.afterClassAddClassDetail =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/AfterClassAddClassDetail',
      request,
      metadata || {},
      methodDescriptor_Api_AfterClassAddClassDetail,
      callback);
};


/**
 * @param {!proto.base.CourseStandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.afterClassAddClassDetail =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/AfterClassAddClassDetail',
      request,
      metadata || {},
      methodDescriptor_Api_AfterClassAddClassDetail);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_OrderListQuery = new grpc.web.MethodDescriptor(
  '/base.Api/OrderListQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_OrderListQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.orderListQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/OrderListQuery',
      request,
      metadata || {},
      methodDescriptor_Api_OrderListQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.orderListQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/OrderListQuery',
      request,
      metadata || {},
      methodDescriptor_Api_OrderListQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_OrderAddByManager = new grpc.web.MethodDescriptor(
  '/base.Api/OrderAddByManager',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_OrderAddByManager = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.orderAddByManager =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/OrderAddByManager',
      request,
      metadata || {},
      methodDescriptor_Api_OrderAddByManager,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.orderAddByManager =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/OrderAddByManager',
      request,
      metadata || {},
      methodDescriptor_Api_OrderAddByManager);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_OrderCancelByManager = new grpc.web.MethodDescriptor(
  '/base.Api/OrderCancelByManager',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_OrderCancelByManager = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.orderCancelByManager =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/OrderCancelByManager',
      request,
      metadata || {},
      methodDescriptor_Api_OrderCancelByManager,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.orderCancelByManager =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/OrderCancelByManager',
      request,
      metadata || {},
      methodDescriptor_Api_OrderCancelByManager);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_OrderStatistics = new grpc.web.MethodDescriptor(
  '/base.Api/OrderStatistics',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_OrderStatistics = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.orderStatistics =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/OrderStatistics',
      request,
      metadata || {},
      methodDescriptor_Api_OrderStatistics,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.orderStatistics =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/OrderStatistics',
      request,
      metadata || {},
      methodDescriptor_Api_OrderStatistics);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ClassOrderQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ClassOrderQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ClassOrderQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.classOrderQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ClassOrderQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ClassOrderQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.classOrderQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ClassOrderQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ClassOrderQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_VipUserOrderQuery = new grpc.web.MethodDescriptor(
  '/base.Api/VipUserOrderQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_VipUserOrderQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.vipUserOrderQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/VipUserOrderQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipUserOrderQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.vipUserOrderQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/VipUserOrderQuery',
      request,
      metadata || {},
      methodDescriptor_Api_VipUserOrderQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_UserOrderQueryByStd = new grpc.web.MethodDescriptor(
  '/base.Api/UserOrderQueryByStd',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_UserOrderQueryByStd = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.userOrderQueryByStd =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/UserOrderQueryByStd',
      request,
      metadata || {},
      methodDescriptor_Api_UserOrderQueryByStd,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.userOrderQueryByStd =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/UserOrderQueryByStd',
      request,
      metadata || {},
      methodDescriptor_Api_UserOrderQueryByStd);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_HrSensorsPublicQuery = new grpc.web.MethodDescriptor(
  '/base.Api/HrSensorsPublicQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_HrSensorsPublicQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.hrSensorsPublicQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/HrSensorsPublicQuery',
      request,
      metadata || {},
      methodDescriptor_Api_HrSensorsPublicQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.hrSensorsPublicQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/HrSensorsPublicQuery',
      request,
      metadata || {},
      methodDescriptor_Api_HrSensorsPublicQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_HrSensorsPvtQuery = new grpc.web.MethodDescriptor(
  '/base.Api/HrSensorsPvtQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_HrSensorsPvtQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.hrSensorsPvtQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/HrSensorsPvtQuery',
      request,
      metadata || {},
      methodDescriptor_Api_HrSensorsPvtQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.hrSensorsPvtQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/HrSensorsPvtQuery',
      request,
      metadata || {},
      methodDescriptor_Api_HrSensorsPvtQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_AddHrSensors = new grpc.web.MethodDescriptor(
  '/base.Api/AddHrSensors',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_AddHrSensors = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.addHrSensors =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/AddHrSensors',
      request,
      metadata || {},
      methodDescriptor_Api_AddHrSensors,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.addHrSensors =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/AddHrSensors',
      request,
      metadata || {},
      methodDescriptor_Api_AddHrSensors);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_AddPvtHrSensors = new grpc.web.MethodDescriptor(
  '/base.Api/AddPvtHrSensors',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_AddPvtHrSensors = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.addPvtHrSensors =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/AddPvtHrSensors',
      request,
      metadata || {},
      methodDescriptor_Api_AddPvtHrSensors,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.addPvtHrSensors =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/AddPvtHrSensors',
      request,
      metadata || {},
      methodDescriptor_Api_AddPvtHrSensors);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_EditHrSensors = new grpc.web.MethodDescriptor(
  '/base.Api/EditHrSensors',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_EditHrSensors = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.editHrSensors =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/EditHrSensors',
      request,
      metadata || {},
      methodDescriptor_Api_EditHrSensors,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.editHrSensors =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/EditHrSensors',
      request,
      metadata || {},
      methodDescriptor_Api_EditHrSensors);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_HrSensorsDel = new grpc.web.MethodDescriptor(
  '/base.Api/HrSensorsDel',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_HrSensorsDel = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.hrSensorsDel =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/HrSensorsDel',
      request,
      metadata || {},
      methodDescriptor_Api_HrSensorsDel,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.hrSensorsDel =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/HrSensorsDel',
      request,
      metadata || {},
      methodDescriptor_Api_HrSensorsDel);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_PKGroupChg = new grpc.web.MethodDescriptor(
  '/base.Api/PKGroupChg',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_PKGroupChg = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.pKGroupChg =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/PKGroupChg',
      request,
      metadata || {},
      methodDescriptor_Api_PKGroupChg,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.pKGroupChg =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/PKGroupChg',
      request,
      metadata || {},
      methodDescriptor_Api_PKGroupChg);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_BindHrSensor = new grpc.web.MethodDescriptor(
  '/base.Api/BindHrSensor',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_BindHrSensor = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.bindHrSensor =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/BindHrSensor',
      request,
      metadata || {},
      methodDescriptor_Api_BindHrSensor,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.bindHrSensor =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/BindHrSensor',
      request,
      metadata || {},
      methodDescriptor_Api_BindHrSensor);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_UnBindHrSensor = new grpc.web.MethodDescriptor(
  '/base.Api/UnBindHrSensor',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_UnBindHrSensor = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.unBindHrSensor =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/UnBindHrSensor',
      request,
      metadata || {},
      methodDescriptor_Api_UnBindHrSensor,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.unBindHrSensor =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/UnBindHrSensor',
      request,
      metadata || {},
      methodDescriptor_Api_UnBindHrSensor);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_ActionQuery = new grpc.web.MethodDescriptor(
  '/base.Api/ActionQuery',
  grpc.web.MethodType.UNARY,
  proto.base.StandardRequest,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.StandardRequest,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_ActionQuery = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.StandardRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.actionQuery =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/ActionQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ActionQuery,
      callback);
};


/**
 * @param {!proto.base.StandardRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.actionQuery =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/ActionQuery',
      request,
      metadata || {},
      methodDescriptor_Api_ActionQuery);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.GenVerifyImageRequest,
 *   !proto.base.GenVerifyImageReply>}
 */
const methodDescriptor_Api_GenVerifyImageByWinXin = new grpc.web.MethodDescriptor(
  '/base.Api/GenVerifyImageByWinXin',
  grpc.web.MethodType.UNARY,
  proto.base.GenVerifyImageRequest,
  proto.base.GenVerifyImageReply,
  /**
   * @param {!proto.base.GenVerifyImageRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.GenVerifyImageReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.GenVerifyImageRequest,
 *   !proto.base.GenVerifyImageReply>}
 */
const methodInfo_Api_GenVerifyImageByWinXin = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.GenVerifyImageReply,
  /**
   * @param {!proto.base.GenVerifyImageRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.GenVerifyImageReply.deserializeBinary
);


/**
 * @param {!proto.base.GenVerifyImageRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.GenVerifyImageReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.GenVerifyImageReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.genVerifyImageByWinXin =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/GenVerifyImageByWinXin',
      request,
      metadata || {},
      methodDescriptor_Api_GenVerifyImageByWinXin,
      callback);
};


/**
 * @param {!proto.base.GenVerifyImageRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.GenVerifyImageReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.genVerifyImageByWinXin =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/GenVerifyImageByWinXin',
      request,
      metadata || {},
      methodDescriptor_Api_GenVerifyImageByWinXin);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.GenPhoneVerifyCodeRequestWX,
 *   !proto.base.StandardReply>}
 */
const methodDescriptor_Api_GenPhoneVerifyCodeByWeiXin = new grpc.web.MethodDescriptor(
  '/base.Api/GenPhoneVerifyCodeByWeiXin',
  grpc.web.MethodType.UNARY,
  proto.base.GenPhoneVerifyCodeRequestWX,
  proto.base.StandardReply,
  /**
   * @param {!proto.base.GenPhoneVerifyCodeRequestWX} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.GenPhoneVerifyCodeRequestWX,
 *   !proto.base.StandardReply>}
 */
const methodInfo_Api_GenPhoneVerifyCodeByWeiXin = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.StandardReply,
  /**
   * @param {!proto.base.GenPhoneVerifyCodeRequestWX} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.StandardReply.deserializeBinary
);


/**
 * @param {!proto.base.GenPhoneVerifyCodeRequestWX} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.StandardReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.StandardReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.genPhoneVerifyCodeByWeiXin =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/GenPhoneVerifyCodeByWeiXin',
      request,
      metadata || {},
      methodDescriptor_Api_GenPhoneVerifyCodeByWeiXin,
      callback);
};


/**
 * @param {!proto.base.GenPhoneVerifyCodeRequestWX} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.StandardReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.genPhoneVerifyCodeByWeiXin =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/GenPhoneVerifyCodeByWeiXin',
      request,
      metadata || {},
      methodDescriptor_Api_GenPhoneVerifyCodeByWeiXin);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.CheckVerifyCodeRequest,
 *   !proto.base.DefaultReply>}
 */
const methodDescriptor_Api_CheckVerifyCode = new grpc.web.MethodDescriptor(
  '/base.Api/CheckVerifyCode',
  grpc.web.MethodType.UNARY,
  proto.base.CheckVerifyCodeRequest,
  proto.base.DefaultReply,
  /**
   * @param {!proto.base.CheckVerifyCodeRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.DefaultReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.CheckVerifyCodeRequest,
 *   !proto.base.DefaultReply>}
 */
const methodInfo_Api_CheckVerifyCode = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.DefaultReply,
  /**
   * @param {!proto.base.CheckVerifyCodeRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.DefaultReply.deserializeBinary
);


/**
 * @param {!proto.base.CheckVerifyCodeRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.DefaultReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.DefaultReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.checkVerifyCode =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/CheckVerifyCode',
      request,
      metadata || {},
      methodDescriptor_Api_CheckVerifyCode,
      callback);
};


/**
 * @param {!proto.base.CheckVerifyCodeRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.DefaultReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.checkVerifyCode =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/CheckVerifyCode',
      request,
      metadata || {},
      methodDescriptor_Api_CheckVerifyCode);
};


/**
 * @const
 * @type {!grpc.web.MethodDescriptor<
 *   !proto.base.WeiXinSignInRequest,
 *   !proto.base.SignInReply>}
 */
const methodDescriptor_Api_WeiXinSignIn = new grpc.web.MethodDescriptor(
  '/base.Api/WeiXinSignIn',
  grpc.web.MethodType.UNARY,
  proto.base.WeiXinSignInRequest,
  proto.base.SignInReply,
  /**
   * @param {!proto.base.WeiXinSignInRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.SignInReply.deserializeBinary
);


/**
 * @const
 * @type {!grpc.web.AbstractClientBase.MethodInfo<
 *   !proto.base.WeiXinSignInRequest,
 *   !proto.base.SignInReply>}
 */
const methodInfo_Api_WeiXinSignIn = new grpc.web.AbstractClientBase.MethodInfo(
  proto.base.SignInReply,
  /**
   * @param {!proto.base.WeiXinSignInRequest} request
   * @return {!Uint8Array}
   */
  function(request) {
    return request.serializeBinary();
  },
  proto.base.SignInReply.deserializeBinary
);


/**
 * @param {!proto.base.WeiXinSignInRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @param {function(?grpc.web.Error, ?proto.base.SignInReply)}
 *     callback The callback function(error, response)
 * @return {!grpc.web.ClientReadableStream<!proto.base.SignInReply>|undefined}
 *     The XHR Node Readable Stream
 */
proto.base.ApiClient.prototype.weiXinSignIn =
    function(request, metadata, callback) {
  return this.client_.rpcCall(this.hostname_ +
      '/base.Api/WeiXinSignIn',
      request,
      metadata || {},
      methodDescriptor_Api_WeiXinSignIn,
      callback);
};


/**
 * @param {!proto.base.WeiXinSignInRequest} request The
 *     request proto
 * @param {?Object<string, string>} metadata User defined
 *     call metadata
 * @return {!Promise<!proto.base.SignInReply>}
 *     Promise that resolves to the response
 */
proto.base.ApiPromiseClient.prototype.weiXinSignIn =
    function(request, metadata) {
  return this.client_.unaryCall(this.hostname_ +
      '/base.Api/WeiXinSignIn',
      request,
      metadata || {},
      methodDescriptor_Api_WeiXinSignIn);
};


module.exports = proto.base;

