@pureweb/platform-streaming-agent/lib/extensions/sidecar/proto/sidecar_grpc_pb.js

The PureWeb platform streaming agent enables your game to communicate and stream through the PureWeb Platform

// GENERATED CODE -- DO NOT EDIT!
'use strict';
var grpc = require('@grpc/grpc-js');
var sidecar_pb = require('./sidecar_pb.js');
function serialize_com_pureweb_agent_AgentList(arg) {
    if (!(arg instanceof sidecar_pb.AgentList)) {
        throw new Error('Expected argument of type com.pureweb.agent.AgentList');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_AgentList(buffer_arg) {
    return sidecar_pb.AgentList.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_BroadcastMessage(arg) {
    if (!(arg instanceof sidecar_pb.BroadcastMessage)) {
        throw new Error('Expected argument of type com.pureweb.agent.BroadcastMessage');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_BroadcastMessage(buffer_arg) {
    return sidecar_pb.BroadcastMessage.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_GetRemoteAgentsRequest(arg) {
    if (!(arg instanceof sidecar_pb.GetRemoteAgentsRequest)) {
        throw new Error('Expected argument of type com.pureweb.agent.GetRemoteAgentsRequest');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_GetRemoteAgentsRequest(buffer_arg) {
    return sidecar_pb.GetRemoteAgentsRequest.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_HeartBeatRequest(arg) {
    if (!(arg instanceof sidecar_pb.HeartBeatRequest)) {
        throw new Error('Expected argument of type com.pureweb.agent.HeartBeatRequest');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_HeartBeatRequest(buffer_arg) {
    return sidecar_pb.HeartBeatRequest.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_HeartBeatResponse(arg) {
    if (!(arg instanceof sidecar_pb.HeartBeatResponse)) {
        throw new Error('Expected argument of type com.pureweb.agent.HeartBeatResponse');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_HeartBeatResponse(buffer_arg) {
    return sidecar_pb.HeartBeatResponse.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_IncomingMessage(arg) {
    if (!(arg instanceof sidecar_pb.IncomingMessage)) {
        throw new Error('Expected argument of type com.pureweb.agent.IncomingMessage');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_IncomingMessage(buffer_arg) {
    return sidecar_pb.IncomingMessage.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_Key(arg) {
    if (!(arg instanceof sidecar_pb.Key)) {
        throw new Error('Expected argument of type com.pureweb.agent.Key');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_Key(buffer_arg) {
    return sidecar_pb.Key.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_KeyList(arg) {
    if (!(arg instanceof sidecar_pb.KeyList)) {
        throw new Error('Expected argument of type com.pureweb.agent.KeyList');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_KeyList(buffer_arg) {
    return sidecar_pb.KeyList.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_KeyValue(arg) {
    if (!(arg instanceof sidecar_pb.KeyValue)) {
        throw new Error('Expected argument of type com.pureweb.agent.KeyValue');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_KeyValue(buffer_arg) {
    return sidecar_pb.KeyValue.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_MessagingSubscription(arg) {
    if (!(arg instanceof sidecar_pb.MessagingSubscription)) {
        throw new Error('Expected argument of type com.pureweb.agent.MessagingSubscription');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_MessagingSubscription(buffer_arg) {
    return sidecar_pb.MessagingSubscription.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_PresenceEvent(arg) {
    if (!(arg instanceof sidecar_pb.PresenceEvent)) {
        throw new Error('Expected argument of type com.pureweb.agent.PresenceEvent');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_PresenceEvent(buffer_arg) {
    return sidecar_pb.PresenceEvent.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_PresenceSubscription(arg) {
    if (!(arg instanceof sidecar_pb.PresenceSubscription)) {
        throw new Error('Expected argument of type com.pureweb.agent.PresenceSubscription');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_PresenceSubscription(buffer_arg) {
    return sidecar_pb.PresenceSubscription.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_PrivateMessage(arg) {
    if (!(arg instanceof sidecar_pb.PrivateMessage)) {
        throw new Error('Expected argument of type com.pureweb.agent.PrivateMessage');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_PrivateMessage(buffer_arg) {
    return sidecar_pb.PrivateMessage.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_RemoveKeyResponse(arg) {
    if (!(arg instanceof sidecar_pb.RemoveKeyResponse)) {
        throw new Error('Expected argument of type com.pureweb.agent.RemoveKeyResponse');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_RemoveKeyResponse(buffer_arg) {
    return sidecar_pb.RemoveKeyResponse.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_RetrieveAllKeysRequest(arg) {
    if (!(arg instanceof sidecar_pb.RetrieveAllKeysRequest)) {
        throw new Error('Expected argument of type com.pureweb.agent.RetrieveAllKeysRequest');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_RetrieveAllKeysRequest(buffer_arg) {
    return sidecar_pb.RetrieveAllKeysRequest.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_SendBroadcastMessageResponse(arg) {
    if (!(arg instanceof sidecar_pb.SendBroadcastMessageResponse)) {
        throw new Error('Expected argument of type com.pureweb.agent.SendBroadcastMessageResponse');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_SendBroadcastMessageResponse(buffer_arg) {
    return sidecar_pb.SendBroadcastMessageResponse.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_SendDirectMessageResponse(arg) {
    if (!(arg instanceof sidecar_pb.SendDirectMessageResponse)) {
        throw new Error('Expected argument of type com.pureweb.agent.SendDirectMessageResponse');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_SendDirectMessageResponse(buffer_arg) {
    return sidecar_pb.SendDirectMessageResponse.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_StorageEvent(arg) {
    if (!(arg instanceof sidecar_pb.StorageEvent)) {
        throw new Error('Expected argument of type com.pureweb.agent.StorageEvent');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_StorageEvent(buffer_arg) {
    return sidecar_pb.StorageEvent.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_StorageSubscription(arg) {
    if (!(arg instanceof sidecar_pb.StorageSubscription)) {
        throw new Error('Expected argument of type com.pureweb.agent.StorageSubscription');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_StorageSubscription(buffer_arg) {
    return sidecar_pb.StorageSubscription.deserializeBinary(new Uint8Array(buffer_arg));
}
function serialize_com_pureweb_agent_StoreKeyResponse(arg) {
    if (!(arg instanceof sidecar_pb.StoreKeyResponse)) {
        throw new Error('Expected argument of type com.pureweb.agent.StoreKeyResponse');
    }
    return Buffer.from(arg.serializeBinary());
}
function deserialize_com_pureweb_agent_StoreKeyResponse(buffer_arg) {
    return sidecar_pb.StoreKeyResponse.deserializeBinary(new Uint8Array(buffer_arg));
}
var EnvironmentService = exports.EnvironmentService = {
    heartBeat: {
        path: '/com.pureweb.agent.Environment/HeartBeat',
        requestStream: false,
        responseStream: true,
        requestType: sidecar_pb.HeartBeatRequest,
        responseType: sidecar_pb.HeartBeatResponse,
        requestSerialize: serialize_com_pureweb_agent_HeartBeatRequest,
        requestDeserialize: deserialize_com_pureweb_agent_HeartBeatRequest,
        responseSerialize: serialize_com_pureweb_agent_HeartBeatResponse,
        responseDeserialize: deserialize_com_pureweb_agent_HeartBeatResponse,
    },
};
exports.EnvironmentClient = grpc.makeGenericClientConstructor(EnvironmentService, 'Environment');
// The service definitions
var MessagingService = exports.MessagingService = {
    sendBroadcastMessage: {
        path: '/com.pureweb.agent.Messaging/SendBroadcastMessage',
        requestStream: false,
        responseStream: false,
        requestType: sidecar_pb.BroadcastMessage,
        responseType: sidecar_pb.SendBroadcastMessageResponse,
        requestSerialize: serialize_com_pureweb_agent_BroadcastMessage,
        requestDeserialize: deserialize_com_pureweb_agent_BroadcastMessage,
        responseSerialize: serialize_com_pureweb_agent_SendBroadcastMessageResponse,
        responseDeserialize: deserialize_com_pureweb_agent_SendBroadcastMessageResponse,
    },
    sendDirectMessage: {
        path: '/com.pureweb.agent.Messaging/SendDirectMessage',
        requestStream: false,
        responseStream: false,
        requestType: sidecar_pb.PrivateMessage,
        responseType: sidecar_pb.SendDirectMessageResponse,
        requestSerialize: serialize_com_pureweb_agent_PrivateMessage,
        requestDeserialize: deserialize_com_pureweb_agent_PrivateMessage,
        responseSerialize: serialize_com_pureweb_agent_SendDirectMessageResponse,
        responseDeserialize: deserialize_com_pureweb_agent_SendDirectMessageResponse,
    },
    subscribe: {
        path: '/com.pureweb.agent.Messaging/Subscribe',
        requestStream: false,
        responseStream: true,
        requestType: sidecar_pb.MessagingSubscription,
        responseType: sidecar_pb.IncomingMessage,
        requestSerialize: serialize_com_pureweb_agent_MessagingSubscription,
        requestDeserialize: deserialize_com_pureweb_agent_MessagingSubscription,
        responseSerialize: serialize_com_pureweb_agent_IncomingMessage,
        responseDeserialize: deserialize_com_pureweb_agent_IncomingMessage,
    },
};
exports.MessagingClient = grpc.makeGenericClientConstructor(MessagingService, 'Messaging');
var PresenceService = exports.PresenceService = {
    getRemoteAgents: {
        path: '/com.pureweb.agent.Presence/GetRemoteAgents',
        requestStream: false,
        responseStream: false,
        requestType: sidecar_pb.GetRemoteAgentsRequest,
        responseType: sidecar_pb.AgentList,
        requestSerialize: serialize_com_pureweb_agent_GetRemoteAgentsRequest,
        requestDeserialize: deserialize_com_pureweb_agent_GetRemoteAgentsRequest,
        responseSerialize: serialize_com_pureweb_agent_AgentList,
        responseDeserialize: deserialize_com_pureweb_agent_AgentList,
    },
    subscribe: {
        path: '/com.pureweb.agent.Presence/Subscribe',
        requestStream: false,
        responseStream: true,
        requestType: sidecar_pb.PresenceSubscription,
        responseType: sidecar_pb.PresenceEvent,
        requestSerialize: serialize_com_pureweb_agent_PresenceSubscription,
        requestDeserialize: deserialize_com_pureweb_agent_PresenceSubscription,
        responseSerialize: serialize_com_pureweb_agent_PresenceEvent,
        responseDeserialize: deserialize_com_pureweb_agent_PresenceEvent,
    },
};
exports.PresenceClient = grpc.makeGenericClientConstructor(PresenceService, 'Presence');
var StorageService = exports.StorageService = {
    store: {
        path: '/com.pureweb.agent.Storage/Store',
        requestStream: false,
        responseStream: false,
        requestType: sidecar_pb.KeyValue,
        responseType: sidecar_pb.StoreKeyResponse,
        requestSerialize: serialize_com_pureweb_agent_KeyValue,
        requestDeserialize: deserialize_com_pureweb_agent_KeyValue,
        responseSerialize: serialize_com_pureweb_agent_StoreKeyResponse,
        responseDeserialize: deserialize_com_pureweb_agent_StoreKeyResponse,
    },
    retrieve: {
        path: '/com.pureweb.agent.Storage/Retrieve',
        requestStream: false,
        responseStream: false,
        requestType: sidecar_pb.Key,
        responseType: sidecar_pb.KeyValue,
        requestSerialize: serialize_com_pureweb_agent_Key,
        requestDeserialize: deserialize_com_pureweb_agent_Key,
        responseSerialize: serialize_com_pureweb_agent_KeyValue,
        responseDeserialize: deserialize_com_pureweb_agent_KeyValue,
    },
    remove: {
        path: '/com.pureweb.agent.Storage/Remove',
        requestStream: false,
        responseStream: false,
        requestType: sidecar_pb.Key,
        responseType: sidecar_pb.RemoveKeyResponse,
        requestSerialize: serialize_com_pureweb_agent_Key,
        requestDeserialize: deserialize_com_pureweb_agent_Key,
        responseSerialize: serialize_com_pureweb_agent_RemoveKeyResponse,
        responseDeserialize: deserialize_com_pureweb_agent_RemoveKeyResponse,
    },
    retrieveAllKeys: {
        path: '/com.pureweb.agent.Storage/RetrieveAllKeys',
        requestStream: false,
        responseStream: false,
        requestType: sidecar_pb.RetrieveAllKeysRequest,
        responseType: sidecar_pb.KeyList,
        requestSerialize: serialize_com_pureweb_agent_RetrieveAllKeysRequest,
        requestDeserialize: deserialize_com_pureweb_agent_RetrieveAllKeysRequest,
        responseSerialize: serialize_com_pureweb_agent_KeyList,
        responseDeserialize: deserialize_com_pureweb_agent_KeyList,
    },
    subscribe: {
        path: '/com.pureweb.agent.Storage/Subscribe',
        requestStream: false,
        responseStream: true,
        requestType: sidecar_pb.StorageSubscription,
        responseType: sidecar_pb.StorageEvent,
        requestSerialize: serialize_com_pureweb_agent_StorageSubscription,
        requestDeserialize: deserialize_com_pureweb_agent_StorageSubscription,
        responseSerialize: serialize_com_pureweb_agent_StorageEvent,
        responseDeserialize: deserialize_com_pureweb_agent_StorageEvent,
    },
};
exports.StorageClient = grpc.makeGenericClientConstructor(StorageService, 'Storage');