@dcl/protocol 1.0.0-10043247792.commit-428d1eb

package/out-ts/decentraland/kernel/apis/engine_api.gen.ts

@@ -0,0 +1,1587 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { EntityAction } from "../../sdk/ecs6/engine_interface_ecs6.gen";
+
+export const protobufPackage = "decentraland.kernel.apis";
+
+/** Events */
+export enum EventDataType {
+  EDT_GENERIC = 0,
+  EDT_POSITION_CHANGED = 1,
+  EDT_ROTATION_CHANGED = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function eventDataTypeFromJSON(object: any): EventDataType {
+  switch (object) {
+    case 0:
+    case "EDT_GENERIC":
+      return EventDataType.EDT_GENERIC;
+    case 1:
+    case "EDT_POSITION_CHANGED":
+      return EventDataType.EDT_POSITION_CHANGED;
+    case 2:
+    case "EDT_ROTATION_CHANGED":
+      return EventDataType.EDT_ROTATION_CHANGED;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return EventDataType.UNRECOGNIZED;
+  }
+}
+
+export function eventDataTypeToJSON(object: EventDataType): string {
+  switch (object) {
+    case EventDataType.EDT_GENERIC:
+      return "EDT_GENERIC";
+    case EventDataType.EDT_POSITION_CHANGED:
+      return "EDT_POSITION_CHANGED";
+    case EventDataType.EDT_ROTATION_CHANGED:
+      return "EDT_ROTATION_CHANGED";
+    case EventDataType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface ManyEntityAction {
+  actions: EntityAction[];
+}
+
+export interface SendBatchResponse {
+  events: EventData[];
+}
+
+export interface UnsubscribeRequest {
+  eventId: string;
+}
+
+export interface SubscribeRequest {
+  eventId: string;
+}
+
+export interface SubscribeResponse {
+}
+
+export interface UnsubscribeResponse {
+}
+
+export interface GenericPayload {
+  eventId: string;
+  eventData: string;
+}
+
+export interface ReadOnlyVector3 {
+  x: number;
+  y: number;
+  z: number;
+}
+
+export interface ReadOnlyQuaternion {
+  x: number;
+  y: number;
+  z: number;
+  w: number;
+}
+
+export interface PositionChangedPayload {
+  position: ReadOnlyVector3 | undefined;
+  cameraPosition: ReadOnlyVector3 | undefined;
+  playerHeight: number;
+}
+
+export interface RotationChangedPayload {
+  rotation: ReadOnlyVector3 | undefined;
+  quaternion: ReadOnlyQuaternion | undefined;
+}
+
+export interface EventData {
+  type: EventDataType;
+  generic?: GenericPayload | undefined;
+  positionChanged?: PositionChangedPayload | undefined;
+  rotationChanged?: RotationChangedPayload | undefined;
+}
+
+export interface CrdtSendToRendererRequest {
+  data: Uint8Array;
+}
+
+export interface CrdtSendToResponse {
+  /** list of CRDT messages coming back from the renderer */
+  data: Uint8Array[];
+}
+
+export interface CrdtGetStateRequest {
+}
+
+export interface CrdtGetStateResponse {
+  /** returns true if the returned state has scene-created entities */
+  hasEntities: boolean;
+  /** static entities data (root entity, camera, etc) and scene-created entities */
+  data: Uint8Array[];
+}
+
+/** deprecated */
+export interface CrdtMessageFromRendererRequest {
+}
+
+/** deprecated */
+export interface CrdtMessageFromRendererResponse {
+  data: Uint8Array[];
+}
+
+export interface IsServerRequest {
+}
+
+export interface IsServerResponse {
+  isServer: boolean;
+}
+
+function createBaseManyEntityAction(): ManyEntityAction {
+  return { actions: [] };
+}
+
+export namespace ManyEntityAction {
+  export function encode(message: ManyEntityAction, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.actions) {
+      EntityAction.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ManyEntityAction {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseManyEntityAction();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.actions.push(EntityAction.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ManyEntityAction {
+    return { actions: Array.isArray(object?.actions) ? object.actions.map((e: any) => EntityAction.fromJSON(e)) : [] };
+  }
+
+  export function toJSON(message: ManyEntityAction): unknown {
+    const obj: any = {};
+    if (message.actions) {
+      obj.actions = message.actions.map((e) => e ? EntityAction.toJSON(e) : undefined);
+    } else {
+      obj.actions = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ManyEntityAction>, I>>(base?: I): ManyEntityAction {
+    return ManyEntityAction.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ManyEntityAction>, I>>(object: I): ManyEntityAction {
+    const message = createBaseManyEntityAction();
+    message.actions = object.actions?.map((e) => EntityAction.fromPartial(e)) || [];
+    return message;
+  }
+}
+
+function createBaseSendBatchResponse(): SendBatchResponse {
+  return { events: [] };
+}
+
+export namespace SendBatchResponse {
+  export function encode(message: SendBatchResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.events) {
+      EventData.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SendBatchResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSendBatchResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.events.push(EventData.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): SendBatchResponse {
+    return { events: Array.isArray(object?.events) ? object.events.map((e: any) => EventData.fromJSON(e)) : [] };
+  }
+
+  export function toJSON(message: SendBatchResponse): unknown {
+    const obj: any = {};
+    if (message.events) {
+      obj.events = message.events.map((e) => e ? EventData.toJSON(e) : undefined);
+    } else {
+      obj.events = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SendBatchResponse>, I>>(base?: I): SendBatchResponse {
+    return SendBatchResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SendBatchResponse>, I>>(object: I): SendBatchResponse {
+    const message = createBaseSendBatchResponse();
+    message.events = object.events?.map((e) => EventData.fromPartial(e)) || [];
+    return message;
+  }
+}
+
+function createBaseUnsubscribeRequest(): UnsubscribeRequest {
+  return { eventId: "" };
+}
+
+export namespace UnsubscribeRequest {
+  export function encode(message: UnsubscribeRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.eventId !== "") {
+      writer.uint32(10).string(message.eventId);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UnsubscribeRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUnsubscribeRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.eventId = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): UnsubscribeRequest {
+    return { eventId: isSet(object.eventId) ? String(object.eventId) : "" };
+  }
+
+  export function toJSON(message: UnsubscribeRequest): unknown {
+    const obj: any = {};
+    message.eventId !== undefined && (obj.eventId = message.eventId);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UnsubscribeRequest>, I>>(base?: I): UnsubscribeRequest {
+    return UnsubscribeRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UnsubscribeRequest>, I>>(object: I): UnsubscribeRequest {
+    const message = createBaseUnsubscribeRequest();
+    message.eventId = object.eventId ?? "";
+    return message;
+  }
+}
+
+function createBaseSubscribeRequest(): SubscribeRequest {
+  return { eventId: "" };
+}
+
+export namespace SubscribeRequest {
+  export function encode(message: SubscribeRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.eventId !== "") {
+      writer.uint32(10).string(message.eventId);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSubscribeRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.eventId = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): SubscribeRequest {
+    return { eventId: isSet(object.eventId) ? String(object.eventId) : "" };
+  }
+
+  export function toJSON(message: SubscribeRequest): unknown {
+    const obj: any = {};
+    message.eventId !== undefined && (obj.eventId = message.eventId);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SubscribeRequest>, I>>(base?: I): SubscribeRequest {
+    return SubscribeRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SubscribeRequest>, I>>(object: I): SubscribeRequest {
+    const message = createBaseSubscribeRequest();
+    message.eventId = object.eventId ?? "";
+    return message;
+  }
+}
+
+function createBaseSubscribeResponse(): SubscribeResponse {
+  return {};
+}
+
+export namespace SubscribeResponse {
+  export function encode(_: SubscribeResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSubscribeResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(_: any): SubscribeResponse {
+    return {};
+  }
+
+  export function toJSON(_: SubscribeResponse): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SubscribeResponse>, I>>(base?: I): SubscribeResponse {
+    return SubscribeResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SubscribeResponse>, I>>(_: I): SubscribeResponse {
+    const message = createBaseSubscribeResponse();
+    return message;
+  }
+}
+
+function createBaseUnsubscribeResponse(): UnsubscribeResponse {
+  return {};
+}
+
+export namespace UnsubscribeResponse {
+  export function encode(_: UnsubscribeResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UnsubscribeResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUnsubscribeResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(_: any): UnsubscribeResponse {
+    return {};
+  }
+
+  export function toJSON(_: UnsubscribeResponse): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UnsubscribeResponse>, I>>(base?: I): UnsubscribeResponse {
+    return UnsubscribeResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UnsubscribeResponse>, I>>(_: I): UnsubscribeResponse {
+    const message = createBaseUnsubscribeResponse();
+    return message;
+  }
+}
+
+function createBaseGenericPayload(): GenericPayload {
+  return { eventId: "", eventData: "" };
+}
+
+export namespace GenericPayload {
+  export function encode(message: GenericPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.eventId !== "") {
+      writer.uint32(26).string(message.eventId);
+    }
+    if (message.eventData !== "") {
+      writer.uint32(34).string(message.eventData);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GenericPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGenericPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.eventId = reader.string();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.eventData = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): GenericPayload {
+    return {
+      eventId: isSet(object.eventId) ? String(object.eventId) : "",
+      eventData: isSet(object.eventData) ? String(object.eventData) : "",
+    };
+  }
+
+  export function toJSON(message: GenericPayload): unknown {
+    const obj: any = {};
+    message.eventId !== undefined && (obj.eventId = message.eventId);
+    message.eventData !== undefined && (obj.eventData = message.eventData);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<GenericPayload>, I>>(base?: I): GenericPayload {
+    return GenericPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<GenericPayload>, I>>(object: I): GenericPayload {
+    const message = createBaseGenericPayload();
+    message.eventId = object.eventId ?? "";
+    message.eventData = object.eventData ?? "";
+    return message;
+  }
+}
+
+function createBaseReadOnlyVector3(): ReadOnlyVector3 {
+  return { x: 0, y: 0, z: 0 };
+}
+
+export namespace ReadOnlyVector3 {
+  export function encode(message: ReadOnlyVector3, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.x !== 0) {
+      writer.uint32(13).float(message.x);
+    }
+    if (message.y !== 0) {
+      writer.uint32(21).float(message.y);
+    }
+    if (message.z !== 0) {
+      writer.uint32(29).float(message.z);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ReadOnlyVector3 {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReadOnlyVector3();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 13) {
+            break;
+          }
+
+          message.x = reader.float();
+          continue;
+        case 2:
+          if (tag !== 21) {
+            break;
+          }
+
+          message.y = reader.float();
+          continue;
+        case 3:
+          if (tag !== 29) {
+            break;
+          }
+
+          message.z = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ReadOnlyVector3 {
+    return {
+      x: isSet(object.x) ? Number(object.x) : 0,
+      y: isSet(object.y) ? Number(object.y) : 0,
+      z: isSet(object.z) ? Number(object.z) : 0,
+    };
+  }
+
+  export function toJSON(message: ReadOnlyVector3): unknown {
+    const obj: any = {};
+    message.x !== undefined && (obj.x = message.x);
+    message.y !== undefined && (obj.y = message.y);
+    message.z !== undefined && (obj.z = message.z);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ReadOnlyVector3>, I>>(base?: I): ReadOnlyVector3 {
+    return ReadOnlyVector3.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ReadOnlyVector3>, I>>(object: I): ReadOnlyVector3 {
+    const message = createBaseReadOnlyVector3();
+    message.x = object.x ?? 0;
+    message.y = object.y ?? 0;
+    message.z = object.z ?? 0;
+    return message;
+  }
+}
+
+function createBaseReadOnlyQuaternion(): ReadOnlyQuaternion {
+  return { x: 0, y: 0, z: 0, w: 0 };
+}
+
+export namespace ReadOnlyQuaternion {
+  export function encode(message: ReadOnlyQuaternion, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.x !== 0) {
+      writer.uint32(13).float(message.x);
+    }
+    if (message.y !== 0) {
+      writer.uint32(21).float(message.y);
+    }
+    if (message.z !== 0) {
+      writer.uint32(29).float(message.z);
+    }
+    if (message.w !== 0) {
+      writer.uint32(37).float(message.w);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ReadOnlyQuaternion {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReadOnlyQuaternion();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 13) {
+            break;
+          }
+
+          message.x = reader.float();
+          continue;
+        case 2:
+          if (tag !== 21) {
+            break;
+          }
+
+          message.y = reader.float();
+          continue;
+        case 3:
+          if (tag !== 29) {
+            break;
+          }
+
+          message.z = reader.float();
+          continue;
+        case 4:
+          if (tag !== 37) {
+            break;
+          }
+
+          message.w = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ReadOnlyQuaternion {
+    return {
+      x: isSet(object.x) ? Number(object.x) : 0,
+      y: isSet(object.y) ? Number(object.y) : 0,
+      z: isSet(object.z) ? Number(object.z) : 0,
+      w: isSet(object.w) ? Number(object.w) : 0,
+    };
+  }
+
+  export function toJSON(message: ReadOnlyQuaternion): unknown {
+    const obj: any = {};
+    message.x !== undefined && (obj.x = message.x);
+    message.y !== undefined && (obj.y = message.y);
+    message.z !== undefined && (obj.z = message.z);
+    message.w !== undefined && (obj.w = message.w);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ReadOnlyQuaternion>, I>>(base?: I): ReadOnlyQuaternion {
+    return ReadOnlyQuaternion.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ReadOnlyQuaternion>, I>>(object: I): ReadOnlyQuaternion {
+    const message = createBaseReadOnlyQuaternion();
+    message.x = object.x ?? 0;
+    message.y = object.y ?? 0;
+    message.z = object.z ?? 0;
+    message.w = object.w ?? 0;
+    return message;
+  }
+}
+
+function createBasePositionChangedPayload(): PositionChangedPayload {
+  return { position: undefined, cameraPosition: undefined, playerHeight: 0 };
+}
+
+export namespace PositionChangedPayload {
+  export function encode(message: PositionChangedPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.position !== undefined) {
+      ReadOnlyVector3.encode(message.position, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.cameraPosition !== undefined) {
+      ReadOnlyVector3.encode(message.cameraPosition, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.playerHeight !== 0) {
+      writer.uint32(29).float(message.playerHeight);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PositionChangedPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePositionChangedPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.position = ReadOnlyVector3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.cameraPosition = ReadOnlyVector3.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 29) {
+            break;
+          }
+
+          message.playerHeight = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PositionChangedPayload {
+    return {
+      position: isSet(object.position) ? ReadOnlyVector3.fromJSON(object.position) : undefined,
+      cameraPosition: isSet(object.cameraPosition) ? ReadOnlyVector3.fromJSON(object.cameraPosition) : undefined,
+      playerHeight: isSet(object.playerHeight) ? Number(object.playerHeight) : 0,
+    };
+  }
+
+  export function toJSON(message: PositionChangedPayload): unknown {
+    const obj: any = {};
+    message.position !== undefined &&
+      (obj.position = message.position ? ReadOnlyVector3.toJSON(message.position) : undefined);
+    message.cameraPosition !== undefined &&
+      (obj.cameraPosition = message.cameraPosition ? ReadOnlyVector3.toJSON(message.cameraPosition) : undefined);
+    message.playerHeight !== undefined && (obj.playerHeight = message.playerHeight);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PositionChangedPayload>, I>>(base?: I): PositionChangedPayload {
+    return PositionChangedPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PositionChangedPayload>, I>>(
+    object: I,
+  ): PositionChangedPayload {
+    const message = createBasePositionChangedPayload();
+    message.position = (object.position !== undefined && object.position !== null)
+      ? ReadOnlyVector3.fromPartial(object.position)
+      : undefined;
+    message.cameraPosition = (object.cameraPosition !== undefined && object.cameraPosition !== null)
+      ? ReadOnlyVector3.fromPartial(object.cameraPosition)
+      : undefined;
+    message.playerHeight = object.playerHeight ?? 0;
+    return message;
+  }
+}
+
+function createBaseRotationChangedPayload(): RotationChangedPayload {
+  return { rotation: undefined, quaternion: undefined };
+}
+
+export namespace RotationChangedPayload {
+  export function encode(message: RotationChangedPayload, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.rotation !== undefined) {
+      ReadOnlyVector3.encode(message.rotation, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.quaternion !== undefined) {
+      ReadOnlyQuaternion.encode(message.quaternion, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): RotationChangedPayload {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRotationChangedPayload();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.rotation = ReadOnlyVector3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.quaternion = ReadOnlyQuaternion.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): RotationChangedPayload {
+    return {
+      rotation: isSet(object.rotation) ? ReadOnlyVector3.fromJSON(object.rotation) : undefined,
+      quaternion: isSet(object.quaternion) ? ReadOnlyQuaternion.fromJSON(object.quaternion) : undefined,
+    };
+  }
+
+  export function toJSON(message: RotationChangedPayload): unknown {
+    const obj: any = {};
+    message.rotation !== undefined &&
+      (obj.rotation = message.rotation ? ReadOnlyVector3.toJSON(message.rotation) : undefined);
+    message.quaternion !== undefined &&
+      (obj.quaternion = message.quaternion ? ReadOnlyQuaternion.toJSON(message.quaternion) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<RotationChangedPayload>, I>>(base?: I): RotationChangedPayload {
+    return RotationChangedPayload.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<RotationChangedPayload>, I>>(
+    object: I,
+  ): RotationChangedPayload {
+    const message = createBaseRotationChangedPayload();
+    message.rotation = (object.rotation !== undefined && object.rotation !== null)
+      ? ReadOnlyVector3.fromPartial(object.rotation)
+      : undefined;
+    message.quaternion = (object.quaternion !== undefined && object.quaternion !== null)
+      ? ReadOnlyQuaternion.fromPartial(object.quaternion)
+      : undefined;
+    return message;
+  }
+}
+
+function createBaseEventData(): EventData {
+  return { type: 0, generic: undefined, positionChanged: undefined, rotationChanged: undefined };
+}
+
+export namespace EventData {
+  export function encode(message: EventData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.type !== 0) {
+      writer.uint32(8).int32(message.type);
+    }
+    if (message.generic !== undefined) {
+      GenericPayload.encode(message.generic, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.positionChanged !== undefined) {
+      PositionChangedPayload.encode(message.positionChanged, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.rotationChanged !== undefined) {
+      RotationChangedPayload.encode(message.rotationChanged, writer.uint32(34).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): EventData {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.type = reader.int32() as any;
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.generic = GenericPayload.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.positionChanged = PositionChangedPayload.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.rotationChanged = RotationChangedPayload.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): EventData {
+    return {
+      type: isSet(object.type) ? eventDataTypeFromJSON(object.type) : 0,
+      generic: isSet(object.generic) ? GenericPayload.fromJSON(object.generic) : undefined,
+      positionChanged: isSet(object.positionChanged)
+        ? PositionChangedPayload.fromJSON(object.positionChanged)
+        : undefined,
+      rotationChanged: isSet(object.rotationChanged)
+        ? RotationChangedPayload.fromJSON(object.rotationChanged)
+        : undefined,
+    };
+  }
+
+  export function toJSON(message: EventData): unknown {
+    const obj: any = {};
+    message.type !== undefined && (obj.type = eventDataTypeToJSON(message.type));
+    message.generic !== undefined &&
+      (obj.generic = message.generic ? GenericPayload.toJSON(message.generic) : undefined);
+    message.positionChanged !== undefined &&
+      (obj.positionChanged = message.positionChanged
+        ? PositionChangedPayload.toJSON(message.positionChanged)
+        : undefined);
+    message.rotationChanged !== undefined &&
+      (obj.rotationChanged = message.rotationChanged
+        ? RotationChangedPayload.toJSON(message.rotationChanged)
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<EventData>, I>>(base?: I): EventData {
+    return EventData.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<EventData>, I>>(object: I): EventData {
+    const message = createBaseEventData();
+    message.type = object.type ?? 0;
+    message.generic = (object.generic !== undefined && object.generic !== null)
+      ? GenericPayload.fromPartial(object.generic)
+      : undefined;
+    message.positionChanged = (object.positionChanged !== undefined && object.positionChanged !== null)
+      ? PositionChangedPayload.fromPartial(object.positionChanged)
+      : undefined;
+    message.rotationChanged = (object.rotationChanged !== undefined && object.rotationChanged !== null)
+      ? RotationChangedPayload.fromPartial(object.rotationChanged)
+      : undefined;
+    return message;
+  }
+}
+
+function createBaseCrdtSendToRendererRequest(): CrdtSendToRendererRequest {
+  return { data: new Uint8Array(0) };
+}
+
+export namespace CrdtSendToRendererRequest {
+  export function encode(message: CrdtSendToRendererRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.data.length !== 0) {
+      writer.uint32(10).bytes(message.data);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CrdtSendToRendererRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCrdtSendToRendererRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.data = reader.bytes();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): CrdtSendToRendererRequest {
+    return { data: isSet(object.data) ? bytesFromBase64(object.data) : new Uint8Array(0) };
+  }
+
+  export function toJSON(message: CrdtSendToRendererRequest): unknown {
+    const obj: any = {};
+    message.data !== undefined &&
+      (obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array(0)));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CrdtSendToRendererRequest>, I>>(
+    base?: I,
+  ): CrdtSendToRendererRequest {
+    return CrdtSendToRendererRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CrdtSendToRendererRequest>, I>>(
+    object: I,
+  ): CrdtSendToRendererRequest {
+    const message = createBaseCrdtSendToRendererRequest();
+    message.data = object.data ?? new Uint8Array(0);
+    return message;
+  }
+}
+
+function createBaseCrdtSendToResponse(): CrdtSendToResponse {
+  return { data: [] };
+}
+
+export namespace CrdtSendToResponse {
+  export function encode(message: CrdtSendToResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.data) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CrdtSendToResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCrdtSendToResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.data.push(reader.bytes());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): CrdtSendToResponse {
+    return { data: Array.isArray(object?.data) ? object.data.map((e: any) => bytesFromBase64(e)) : [] };
+  }
+
+  export function toJSON(message: CrdtSendToResponse): unknown {
+    const obj: any = {};
+    if (message.data) {
+      obj.data = message.data.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array(0)));
+    } else {
+      obj.data = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CrdtSendToResponse>, I>>(base?: I): CrdtSendToResponse {
+    return CrdtSendToResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CrdtSendToResponse>, I>>(object: I): CrdtSendToResponse {
+    const message = createBaseCrdtSendToResponse();
+    message.data = object.data?.map((e) => e) || [];
+    return message;
+  }
+}
+
+function createBaseCrdtGetStateRequest(): CrdtGetStateRequest {
+  return {};
+}
+
+export namespace CrdtGetStateRequest {
+  export function encode(_: CrdtGetStateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CrdtGetStateRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCrdtGetStateRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(_: any): CrdtGetStateRequest {
+    return {};
+  }
+
+  export function toJSON(_: CrdtGetStateRequest): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CrdtGetStateRequest>, I>>(base?: I): CrdtGetStateRequest {
+    return CrdtGetStateRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CrdtGetStateRequest>, I>>(_: I): CrdtGetStateRequest {
+    const message = createBaseCrdtGetStateRequest();
+    return message;
+  }
+}
+
+function createBaseCrdtGetStateResponse(): CrdtGetStateResponse {
+  return { hasEntities: false, data: [] };
+}
+
+export namespace CrdtGetStateResponse {
+  export function encode(message: CrdtGetStateResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.hasEntities === true) {
+      writer.uint32(8).bool(message.hasEntities);
+    }
+    for (const v of message.data) {
+      writer.uint32(18).bytes(v!);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CrdtGetStateResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCrdtGetStateResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.hasEntities = reader.bool();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.data.push(reader.bytes());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): CrdtGetStateResponse {
+    return {
+      hasEntities: isSet(object.hasEntities) ? Boolean(object.hasEntities) : false,
+      data: Array.isArray(object?.data) ? object.data.map((e: any) => bytesFromBase64(e)) : [],
+    };
+  }
+
+  export function toJSON(message: CrdtGetStateResponse): unknown {
+    const obj: any = {};
+    message.hasEntities !== undefined && (obj.hasEntities = message.hasEntities);
+    if (message.data) {
+      obj.data = message.data.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array(0)));
+    } else {
+      obj.data = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CrdtGetStateResponse>, I>>(base?: I): CrdtGetStateResponse {
+    return CrdtGetStateResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CrdtGetStateResponse>, I>>(object: I): CrdtGetStateResponse {
+    const message = createBaseCrdtGetStateResponse();
+    message.hasEntities = object.hasEntities ?? false;
+    message.data = object.data?.map((e) => e) || [];
+    return message;
+  }
+}
+
+function createBaseCrdtMessageFromRendererRequest(): CrdtMessageFromRendererRequest {
+  return {};
+}
+
+export namespace CrdtMessageFromRendererRequest {
+  export function encode(_: CrdtMessageFromRendererRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CrdtMessageFromRendererRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCrdtMessageFromRendererRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(_: any): CrdtMessageFromRendererRequest {
+    return {};
+  }
+
+  export function toJSON(_: CrdtMessageFromRendererRequest): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CrdtMessageFromRendererRequest>, I>>(
+    base?: I,
+  ): CrdtMessageFromRendererRequest {
+    return CrdtMessageFromRendererRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CrdtMessageFromRendererRequest>, I>>(
+    _: I,
+  ): CrdtMessageFromRendererRequest {
+    const message = createBaseCrdtMessageFromRendererRequest();
+    return message;
+  }
+}
+
+function createBaseCrdtMessageFromRendererResponse(): CrdtMessageFromRendererResponse {
+  return { data: [] };
+}
+
+export namespace CrdtMessageFromRendererResponse {
+  export function encode(
+    message: CrdtMessageFromRendererResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    for (const v of message.data) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CrdtMessageFromRendererResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCrdtMessageFromRendererResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.data.push(reader.bytes());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): CrdtMessageFromRendererResponse {
+    return { data: Array.isArray(object?.data) ? object.data.map((e: any) => bytesFromBase64(e)) : [] };
+  }
+
+  export function toJSON(message: CrdtMessageFromRendererResponse): unknown {
+    const obj: any = {};
+    if (message.data) {
+      obj.data = message.data.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array(0)));
+    } else {
+      obj.data = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CrdtMessageFromRendererResponse>, I>>(
+    base?: I,
+  ): CrdtMessageFromRendererResponse {
+    return CrdtMessageFromRendererResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CrdtMessageFromRendererResponse>, I>>(
+    object: I,
+  ): CrdtMessageFromRendererResponse {
+    const message = createBaseCrdtMessageFromRendererResponse();
+    message.data = object.data?.map((e) => e) || [];
+    return message;
+  }
+}
+
+function createBaseIsServerRequest(): IsServerRequest {
+  return {};
+}
+
+export namespace IsServerRequest {
+  export function encode(_: IsServerRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): IsServerRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIsServerRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(_: any): IsServerRequest {
+    return {};
+  }
+
+  export function toJSON(_: IsServerRequest): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<IsServerRequest>, I>>(base?: I): IsServerRequest {
+    return IsServerRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<IsServerRequest>, I>>(_: I): IsServerRequest {
+    const message = createBaseIsServerRequest();
+    return message;
+  }
+}
+
+function createBaseIsServerResponse(): IsServerResponse {
+  return { isServer: false };
+}
+
+export namespace IsServerResponse {
+  export function encode(message: IsServerResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.isServer === true) {
+      writer.uint32(8).bool(message.isServer);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): IsServerResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseIsServerResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.isServer = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): IsServerResponse {
+    return { isServer: isSet(object.isServer) ? Boolean(object.isServer) : false };
+  }
+
+  export function toJSON(message: IsServerResponse): unknown {
+    const obj: any = {};
+    message.isServer !== undefined && (obj.isServer = message.isServer);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<IsServerResponse>, I>>(base?: I): IsServerResponse {
+    return IsServerResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<IsServerResponse>, I>>(object: I): IsServerResponse {
+    const message = createBaseIsServerResponse();
+    message.isServer = object.isServer ?? false;
+    return message;
+  }
+}
+
+/** support for legacy SDK events. */
+export type EngineApiServiceDefinition = typeof EngineApiServiceDefinition;
+export const EngineApiServiceDefinition = {
+  name: "EngineApiService",
+  fullName: "decentraland.kernel.apis.EngineApiService",
+  methods: {
+    /** @deprecated */
+    sendBatch: {
+      name: "SendBatch",
+      requestType: ManyEntityAction,
+      requestStream: false,
+      responseType: SendBatchResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** @deprecated */
+    subscribe: {
+      name: "Subscribe",
+      requestType: SubscribeRequest,
+      requestStream: false,
+      responseType: SubscribeResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** @deprecated */
+    unsubscribe: {
+      name: "Unsubscribe",
+      requestType: UnsubscribeRequest,
+      requestStream: false,
+      responseType: UnsubscribeResponse,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * send information of the CRDT messages to the renderer. It returns the CRDT changes back from the renderer
+     * like raycast responses or the player's position
+     */
+    crdtSendToRenderer: {
+      name: "CrdtSendToRenderer",
+      requestType: CrdtSendToRendererRequest,
+      requestStream: false,
+      responseType: CrdtSendToResponse,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * retrieves the current _full_ state of the entities from the renderer. This function is used to hidrate
+     * the state of the scenes when the code of the worker is stopped/resumed
+     */
+    crdtGetState: {
+      name: "CrdtGetState",
+      requestType: CrdtSendToRendererRequest,
+      requestStream: false,
+      responseType: CrdtGetStateResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** @deprecated, this response was merged into CrdtSendToResponse */
+    crdtGetMessageFromRenderer: {
+      name: "CrdtGetMessageFromRenderer",
+      requestType: CrdtMessageFromRendererRequest,
+      requestStream: false,
+      responseType: CrdtMessageFromRendererResponse,
+      responseStream: false,
+      options: {},
+    },
+    isServer: {
+      name: "IsServer",
+      requestType: IsServerRequest,
+      requestStream: false,
+      responseType: IsServerResponse,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+declare const self: any | undefined;
+declare const window: any | undefined;
+declare const global: any | undefined;
+const tsProtoGlobalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if (tsProtoGlobalThis.Buffer) {
+    return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = tsProtoGlobalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (tsProtoGlobalThis.Buffer) {
+    return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(String.fromCharCode(byte));
+    });
+    return tsProtoGlobalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}