protobuf-platform 1.2.282 → 1.2.283

package/index.js

@@ -35,6 +35,8 @@ const SchedulerService = require('./scheduler/scheduler_grpc_pb');
 const SchedulerServiceMessages = require('./scheduler/scheduler_pb');
 const SportService = require('./sport/sport_grpc_pb');
 const SportServiceMessage = require('./sport/sport_pb');
+const PokerService = require('./poker/poker_grpc_pb');
+const PokerServiceMessage = require('./poker/poker_pb');
 module.exports = {
     gRPC: gRPC,
     maxSendMessageLength: 10388608,
@@ -108,4 +110,8 @@ module.exports = {
         service: SportService,
         messages: SportServiceMessage
     },
+    poker: {
+        service: PokerService,
+        messages: PokerServiceMessage
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protobuf-platform",
-  "version": "1.2.282",
+  "version": "1.2.283",
   "description": "Protobuf structures",
   "main": "index.js",
   "scripts": {

package/poker/poker.proto

@@ -0,0 +1,113 @@
+syntax = "proto3";
+
+package sport;
+
+service Sport {
+    rpc checkConnection(PingRequest) returns (PongResponse);
+    // Launch Betby sportsbook widget for user or guest.
+    rpc launchBetby(LaunchBetbyRequest) returns (LaunchBetbyResponse);
+    rpc runSelfValidationBetby(selfValidationBetbyRequest) returns (selfValidationBetbyResponse);
+    rpc checkSelfValidationBetby(selfValidationBetbyRequest) returns (selfValidationBetbyResponse);
+    // Vendor callback.
+    rpc processedVendorActionCallback(VendorActionRequest) returns (VendorActionResponse);
+
+    // Sport meta
+    rpc getSportCategoriesByIds(SportCategoriesIds) returns (SportCategoriesResponse);
+    rpc getSportTypesByIds(SportTypesIds) returns (SportTypesResponse);
+}
+
+message PingRequest { string ping = 1; }
+message PongResponse { string pong = 1; }
+
+message PaginationRequest {
+    int32 limit = 1;
+    int32 offset = 2;
+    optional string order = 3;
+}
+
+// Launch request for Betby sportsbook.
+message LaunchBetbyRequest {
+    // Optional: internal user identifier, empty for guest.
+    optional int32 user_id = 1;
+    optional string user_public_id = 2;
+
+    // Player currency, e.g. "EUR".
+    optional string currency = 3;
+
+    // Player language, e.g. "en-US".
+    optional string language = 4;
+
+    // URL to return player after sportsbook session end.
+    optional string return_url = 5;
+
+    // Client IP address for Betby (X-Client-Ip).
+    optional string client_ip = 6;
+
+    optional string player_name = 7;
+    optional string session_id = 8;
+    optional int32 sticky_top = 9;
+    optional int32 bet_slip_offset_top = 10;
+    optional int32 bet_slip_offset_bottom = 11;
+}
+
+// Launch response with rendered Betby widget.
+message LaunchBetbyResponse {
+    // Rendered HTML snippet to inject on frontend.
+    string html = 1;
+
+    // Launch mode: "guest" or "player".
+    optional string mode = 2;
+}
+
+// Vendor
+message VendorActionRequest {
+    string data = 1;
+}
+
+message VendorActionResponse {
+    string data = 1;
+}
+
+// Self validation Betby
+message selfValidationBetbyRequest {
+    optional string session_id = 1;
+    optional string player_id = 2;
+    optional string currency = 3;
+    optional string task_id = 4;
+}
+
+message selfValidationBetbyResponse {
+    string result = 1;
+}
+
+// Sport meta: categories
+message SportCategoryItem {
+    int32 id = 1;
+    string title = 2;
+    optional string group = 3;
+    optional bool is_live_supported = 4;
+}
+
+message SportCategoriesIds {
+    repeated int32 ids = 1;
+}
+
+message SportCategoriesResponse {
+    repeated SportCategoryItem items = 1;
+}
+
+// Sport meta: types
+message SportTypeItem {
+    int32 id = 1;
+    string title = 2;
+    optional int32 sport_category_id = 3;
+    optional string market_group = 4;
+}
+
+message SportTypesIds {
+    repeated int32 ids = 1;
+}
+
+message SportTypesResponse {
+    repeated SportTypeItem items = 1;
+}

package/poker/poker_grpc_pb.js

@@ -0,0 +1,223 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+'use strict';
+var grpc = require('@grpc/grpc-js');
+var poker_pb = require('./poker_pb.js');
+
+function serialize_sport_LaunchBetbyRequest(arg) {
+  if (!(arg instanceof poker_pb.LaunchBetbyRequest)) {
+    throw new Error('Expected argument of type sport.LaunchBetbyRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_LaunchBetbyRequest(buffer_arg) {
+  return poker_pb.LaunchBetbyRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_LaunchBetbyResponse(arg) {
+  if (!(arg instanceof poker_pb.LaunchBetbyResponse)) {
+    throw new Error('Expected argument of type sport.LaunchBetbyResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_LaunchBetbyResponse(buffer_arg) {
+  return poker_pb.LaunchBetbyResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_PingRequest(arg) {
+  if (!(arg instanceof poker_pb.PingRequest)) {
+    throw new Error('Expected argument of type sport.PingRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_PingRequest(buffer_arg) {
+  return poker_pb.PingRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_PongResponse(arg) {
+  if (!(arg instanceof poker_pb.PongResponse)) {
+    throw new Error('Expected argument of type sport.PongResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_PongResponse(buffer_arg) {
+  return poker_pb.PongResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_SportCategoriesIds(arg) {
+  if (!(arg instanceof poker_pb.SportCategoriesIds)) {
+    throw new Error('Expected argument of type sport.SportCategoriesIds');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_SportCategoriesIds(buffer_arg) {
+  return poker_pb.SportCategoriesIds.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_SportCategoriesResponse(arg) {
+  if (!(arg instanceof poker_pb.SportCategoriesResponse)) {
+    throw new Error('Expected argument of type sport.SportCategoriesResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_SportCategoriesResponse(buffer_arg) {
+  return poker_pb.SportCategoriesResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_SportTypesIds(arg) {
+  if (!(arg instanceof poker_pb.SportTypesIds)) {
+    throw new Error('Expected argument of type sport.SportTypesIds');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_SportTypesIds(buffer_arg) {
+  return poker_pb.SportTypesIds.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_SportTypesResponse(arg) {
+  if (!(arg instanceof poker_pb.SportTypesResponse)) {
+    throw new Error('Expected argument of type sport.SportTypesResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_SportTypesResponse(buffer_arg) {
+  return poker_pb.SportTypesResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_VendorActionRequest(arg) {
+  if (!(arg instanceof poker_pb.VendorActionRequest)) {
+    throw new Error('Expected argument of type sport.VendorActionRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_VendorActionRequest(buffer_arg) {
+  return poker_pb.VendorActionRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_VendorActionResponse(arg) {
+  if (!(arg instanceof poker_pb.VendorActionResponse)) {
+    throw new Error('Expected argument of type sport.VendorActionResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_VendorActionResponse(buffer_arg) {
+  return poker_pb.VendorActionResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_selfValidationBetbyRequest(arg) {
+  if (!(arg instanceof poker_pb.selfValidationBetbyRequest)) {
+    throw new Error('Expected argument of type sport.selfValidationBetbyRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_selfValidationBetbyRequest(buffer_arg) {
+  return poker_pb.selfValidationBetbyRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_sport_selfValidationBetbyResponse(arg) {
+  if (!(arg instanceof poker_pb.selfValidationBetbyResponse)) {
+    throw new Error('Expected argument of type sport.selfValidationBetbyResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_sport_selfValidationBetbyResponse(buffer_arg) {
+  return poker_pb.selfValidationBetbyResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+var SportService = exports.SportService = {
+  checkConnection: {
+    path: '/sport.Sport/checkConnection',
+    requestStream: false,
+    responseStream: false,
+    requestType: poker_pb.PingRequest,
+    responseType: poker_pb.PongResponse,
+    requestSerialize: serialize_sport_PingRequest,
+    requestDeserialize: deserialize_sport_PingRequest,
+    responseSerialize: serialize_sport_PongResponse,
+    responseDeserialize: deserialize_sport_PongResponse,
+  },
+  // Launch Betby sportsbook widget for user or guest.
+launchBetby: {
+    path: '/sport.Sport/launchBetby',
+    requestStream: false,
+    responseStream: false,
+    requestType: poker_pb.LaunchBetbyRequest,
+    responseType: poker_pb.LaunchBetbyResponse,
+    requestSerialize: serialize_sport_LaunchBetbyRequest,
+    requestDeserialize: deserialize_sport_LaunchBetbyRequest,
+    responseSerialize: serialize_sport_LaunchBetbyResponse,
+    responseDeserialize: deserialize_sport_LaunchBetbyResponse,
+  },
+  runSelfValidationBetby: {
+    path: '/sport.Sport/runSelfValidationBetby',
+    requestStream: false,
+    responseStream: false,
+    requestType: poker_pb.selfValidationBetbyRequest,
+    responseType: poker_pb.selfValidationBetbyResponse,
+    requestSerialize: serialize_sport_selfValidationBetbyRequest,
+    requestDeserialize: deserialize_sport_selfValidationBetbyRequest,
+    responseSerialize: serialize_sport_selfValidationBetbyResponse,
+    responseDeserialize: deserialize_sport_selfValidationBetbyResponse,
+  },
+  checkSelfValidationBetby: {
+    path: '/sport.Sport/checkSelfValidationBetby',
+    requestStream: false,
+    responseStream: false,
+    requestType: poker_pb.selfValidationBetbyRequest,
+    responseType: poker_pb.selfValidationBetbyResponse,
+    requestSerialize: serialize_sport_selfValidationBetbyRequest,
+    requestDeserialize: deserialize_sport_selfValidationBetbyRequest,
+    responseSerialize: serialize_sport_selfValidationBetbyResponse,
+    responseDeserialize: deserialize_sport_selfValidationBetbyResponse,
+  },
+  // Vendor callback.
+processedVendorActionCallback: {
+    path: '/sport.Sport/processedVendorActionCallback',
+    requestStream: false,
+    responseStream: false,
+    requestType: poker_pb.VendorActionRequest,
+    responseType: poker_pb.VendorActionResponse,
+    requestSerialize: serialize_sport_VendorActionRequest,
+    requestDeserialize: deserialize_sport_VendorActionRequest,
+    responseSerialize: serialize_sport_VendorActionResponse,
+    responseDeserialize: deserialize_sport_VendorActionResponse,
+  },
+  // Sport meta
+getSportCategoriesByIds: {
+    path: '/sport.Sport/getSportCategoriesByIds',
+    requestStream: false,
+    responseStream: false,
+    requestType: poker_pb.SportCategoriesIds,
+    responseType: poker_pb.SportCategoriesResponse,
+    requestSerialize: serialize_sport_SportCategoriesIds,
+    requestDeserialize: deserialize_sport_SportCategoriesIds,
+    responseSerialize: serialize_sport_SportCategoriesResponse,
+    responseDeserialize: deserialize_sport_SportCategoriesResponse,
+  },
+  getSportTypesByIds: {
+    path: '/sport.Sport/getSportTypesByIds',
+    requestStream: false,
+    responseStream: false,
+    requestType: poker_pb.SportTypesIds,
+    responseType: poker_pb.SportTypesResponse,
+    requestSerialize: serialize_sport_SportTypesIds,
+    requestDeserialize: deserialize_sport_SportTypesIds,
+    responseSerialize: serialize_sport_SportTypesResponse,
+    responseDeserialize: deserialize_sport_SportTypesResponse,
+  },
+};
+
+exports.SportClient = grpc.makeGenericClientConstructor(SportService, 'Sport');