@dcl/protocol 1.0.0-3587979266.commit-9fcad98 → 1.0.0-35899496093.commit-329ba0e

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

@@ -1,290 +1,1625 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
+import { Vector2, Vector3 } from "../../common/vectors.gen";
+import { AvatarMask, avatarMaskFromJSON, avatarMaskToJSON } from "../../sdk/components/common/avatar_mask.gen";
+import { ExplorerUi, explorerUiFromJSON, explorerUiToJSON } from "../../sdk/components/common/explorer_ui.gen";
 
 export const protobufPackage = "decentraland.kernel.apis";
 
-export interface Vector3 {
-  x: number;
-  y: number;
-  z: number;
+/** Verdict of an OpenExplorerUi request (enum rather than a bool so new outcomes stay expressible). */
+export enum OpenExplorerUiResult {
+  UNSPECIFIED = 0,
+  OPENED = 1,
+  /** WAS_ALREADY_OPEN - a fullscreen panel is already open */
+  WAS_ALREADY_OPEN = 2,
+  /** REJECTED_NOT_CURRENT_SCENE - the standard restricted-actions current-scene gate rejected the call */
+  REJECTED_NOT_CURRENT_SCENE = 3,
+  /** REJECTED_FEATURE_DISABLED - the requested section is hidden by feature flags or client doesn't have that feature */
+  REJECTED_FEATURE_DISABLED = 4,
+  /** REJECTED_NO_USER_GESTURE - rejected: the call did not originate from a user gesture */
+  REJECTED_NO_USER_GESTURE = 5,
+  UNRECOGNIZED = -1,
 }
 
-export interface MovePlayerToResponse {
+export function openExplorerUiResultFromJSON(object: any): OpenExplorerUiResult {
+  switch (object) {
+    case 0:
+    case "UNSPECIFIED":
+      return OpenExplorerUiResult.UNSPECIFIED;
+    case 1:
+    case "OPENED":
+      return OpenExplorerUiResult.OPENED;
+    case 2:
+    case "WAS_ALREADY_OPEN":
+      return OpenExplorerUiResult.WAS_ALREADY_OPEN;
+    case 3:
+    case "REJECTED_NOT_CURRENT_SCENE":
+      return OpenExplorerUiResult.REJECTED_NOT_CURRENT_SCENE;
+    case 4:
+    case "REJECTED_FEATURE_DISABLED":
+      return OpenExplorerUiResult.REJECTED_FEATURE_DISABLED;
+    case 5:
+    case "REJECTED_NO_USER_GESTURE":
+      return OpenExplorerUiResult.REJECTED_NO_USER_GESTURE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return OpenExplorerUiResult.UNRECOGNIZED;
+  }
+}
+
+export function openExplorerUiResultToJSON(object: OpenExplorerUiResult): string {
+  switch (object) {
+    case OpenExplorerUiResult.UNSPECIFIED:
+      return "UNSPECIFIED";
+    case OpenExplorerUiResult.OPENED:
+      return "OPENED";
+    case OpenExplorerUiResult.WAS_ALREADY_OPEN:
+      return "WAS_ALREADY_OPEN";
+    case OpenExplorerUiResult.REJECTED_NOT_CURRENT_SCENE:
+      return "REJECTED_NOT_CURRENT_SCENE";
+    case OpenExplorerUiResult.REJECTED_FEATURE_DISABLED:
+      return "REJECTED_FEATURE_DISABLED";
+    case OpenExplorerUiResult.REJECTED_NO_USER_GESTURE:
+      return "REJECTED_NO_USER_GESTURE";
+    case OpenExplorerUiResult.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
 }
 
 export interface MovePlayerToRequest {
   newRelativePosition: Vector3 | undefined;
   cameraTarget?: Vector3 | undefined;
+  avatarTarget?:
+    | Vector3
+    | undefined;
+  /** by default (no duration param) the player is instantly moved and not interpolated */
+  duration?: number | undefined;
+}
+
+export interface TeleportToRequest {
+  /** The parcel to land on. Omitted: the realm's default spawn (only meaningful with `realm`). */
+  worldCoordinates?:
+    | Vector2
+    | undefined;
+  /**
+   * The realm the parcel belongs to: a world name (`foo.dcl.eth`) or a realm url. When set, the
+   * client changes realm (a full reconnect, even to the realm the player is in) and lands on the
+   * parcel there. Omitted: the parcel is in the player's current realm.
+   */
+  realm?: string | undefined;
+}
+
+export interface TriggerEmoteRequest {
+  predefinedEmote: string;
+  mask?: AvatarMask | undefined;
+}
+
+export interface ChangeRealmRequest {
+  realm: string;
+  message?: string | undefined;
+}
+
+export interface OpenExternalUrlRequest {
+  url: string;
+}
+
+export interface OpenNftDialogRequest {
+  urn: string;
+}
+
+export interface UnblockPointerRequest {
+}
+
+export interface CommsAdapterRequest {
+  connectionString: string;
+}
+
+export interface TriggerSceneEmoteRequest {
+  src: string;
+  loop?: boolean | undefined;
+  mask?: AvatarMask | undefined;
+}
+
+export interface SuccessResponse {
+  success: boolean;
+}
+
+export interface TriggerEmoteResponse {
+}
+
+export interface MovePlayerToResponse {
+  success: boolean;
+}
+
+export interface WalkPlayerToRequest {
+  newRelativePosition: Vector3 | undefined;
+  stopThreshold: number;
+  /** max seconds before the request is failed; not passed to the movement scene */
+  timeout?: number | undefined;
+}
+
+export interface WalkPlayerToResponse {
+  success: boolean;
+}
+
+export interface TeleportToResponse {
+}
+
+export interface SetUiFocusRequest {
+  elementId: string;
+}
+
+export interface ClearUiFocusRequest {
+}
+
+export interface GetUiFocusRequest {
+}
+
+export interface UiFocusResponse {
+  /** the element that is/was focussed */
+  elementId?: string | undefined;
+}
+
+export interface CopyToClipboardRequest {
+  text: string;
+}
+
+export interface EmptyResponse {
+}
+
+export interface StopEmoteRequest {
+}
+
+export interface OpenExplorerUiRequest {
+  ui: ExplorerUi;
+}
+
+export interface OpenExplorerUiResponse {
+  /** Carries only the verdict of the open action. */
+  openResult: OpenExplorerUiResult;
+}
+
+function createBaseMovePlayerToRequest(): MovePlayerToRequest {
+  return { newRelativePosition: undefined, cameraTarget: undefined, avatarTarget: undefined, duration: undefined };
+}
+
+export namespace MovePlayerToRequest {
+  export function encode(message: MovePlayerToRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.newRelativePosition !== undefined) {
+      Vector3.encode(message.newRelativePosition, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.cameraTarget !== undefined) {
+      Vector3.encode(message.cameraTarget, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.avatarTarget !== undefined) {
+      Vector3.encode(message.avatarTarget, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.duration !== undefined) {
+      writer.uint32(37).float(message.duration);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): MovePlayerToRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMovePlayerToRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.newRelativePosition = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.cameraTarget = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.avatarTarget = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 37) {
+            break;
+          }
+
+          message.duration = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): MovePlayerToRequest {
+    return {
+      newRelativePosition: isSet(object.newRelativePosition) ? Vector3.fromJSON(object.newRelativePosition) : undefined,
+      cameraTarget: isSet(object.cameraTarget) ? Vector3.fromJSON(object.cameraTarget) : undefined,
+      avatarTarget: isSet(object.avatarTarget) ? Vector3.fromJSON(object.avatarTarget) : undefined,
+      duration: isSet(object.duration) ? Number(object.duration) : undefined,
+    };
+  }
+
+  export function toJSON(message: MovePlayerToRequest): unknown {
+    const obj: any = {};
+    message.newRelativePosition !== undefined &&
+      (obj.newRelativePosition = message.newRelativePosition ? Vector3.toJSON(message.newRelativePosition) : undefined);
+    message.cameraTarget !== undefined &&
+      (obj.cameraTarget = message.cameraTarget ? Vector3.toJSON(message.cameraTarget) : undefined);
+    message.avatarTarget !== undefined &&
+      (obj.avatarTarget = message.avatarTarget ? Vector3.toJSON(message.avatarTarget) : undefined);
+    message.duration !== undefined && (obj.duration = message.duration);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<MovePlayerToRequest>, I>>(base?: I): MovePlayerToRequest {
+    return MovePlayerToRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<MovePlayerToRequest>, I>>(object: I): MovePlayerToRequest {
+    const message = createBaseMovePlayerToRequest();
+    message.newRelativePosition = (object.newRelativePosition !== undefined && object.newRelativePosition !== null)
+      ? Vector3.fromPartial(object.newRelativePosition)
+      : undefined;
+    message.cameraTarget = (object.cameraTarget !== undefined && object.cameraTarget !== null)
+      ? Vector3.fromPartial(object.cameraTarget)
+      : undefined;
+    message.avatarTarget = (object.avatarTarget !== undefined && object.avatarTarget !== null)
+      ? Vector3.fromPartial(object.avatarTarget)
+      : undefined;
+    message.duration = object.duration ?? undefined;
+    return message;
+  }
+}
+
+function createBaseTeleportToRequest(): TeleportToRequest {
+  return { worldCoordinates: undefined, realm: undefined };
+}
+
+export namespace TeleportToRequest {
+  export function encode(message: TeleportToRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.worldCoordinates !== undefined) {
+      Vector2.encode(message.worldCoordinates, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.realm !== undefined) {
+      writer.uint32(18).string(message.realm);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): TeleportToRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTeleportToRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.worldCoordinates = Vector2.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.realm = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): TeleportToRequest {
+    return {
+      worldCoordinates: isSet(object.worldCoordinates) ? Vector2.fromJSON(object.worldCoordinates) : undefined,
+      realm: isSet(object.realm) ? String(object.realm) : undefined,
+    };
+  }
+
+  export function toJSON(message: TeleportToRequest): unknown {
+    const obj: any = {};
+    message.worldCoordinates !== undefined &&
+      (obj.worldCoordinates = message.worldCoordinates ? Vector2.toJSON(message.worldCoordinates) : undefined);
+    message.realm !== undefined && (obj.realm = message.realm);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<TeleportToRequest>, I>>(base?: I): TeleportToRequest {
+    return TeleportToRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<TeleportToRequest>, I>>(object: I): TeleportToRequest {
+    const message = createBaseTeleportToRequest();
+    message.worldCoordinates = (object.worldCoordinates !== undefined && object.worldCoordinates !== null)
+      ? Vector2.fromPartial(object.worldCoordinates)
+      : undefined;
+    message.realm = object.realm ?? undefined;
+    return message;
+  }
+}
+
+function createBaseTriggerEmoteRequest(): TriggerEmoteRequest {
+  return { predefinedEmote: "", mask: undefined };
+}
+
+export namespace TriggerEmoteRequest {
+  export function encode(message: TriggerEmoteRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.predefinedEmote !== "") {
+      writer.uint32(10).string(message.predefinedEmote);
+    }
+    if (message.mask !== undefined) {
+      writer.uint32(16).int32(message.mask);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): TriggerEmoteRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTriggerEmoteRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.predefinedEmote = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.mask = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): TriggerEmoteRequest {
+    return {
+      predefinedEmote: isSet(object.predefinedEmote) ? String(object.predefinedEmote) : "",
+      mask: isSet(object.mask) ? avatarMaskFromJSON(object.mask) : undefined,
+    };
+  }
+
+  export function toJSON(message: TriggerEmoteRequest): unknown {
+    const obj: any = {};
+    message.predefinedEmote !== undefined && (obj.predefinedEmote = message.predefinedEmote);
+    message.mask !== undefined && (obj.mask = message.mask !== undefined ? avatarMaskToJSON(message.mask) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<TriggerEmoteRequest>, I>>(base?: I): TriggerEmoteRequest {
+    return TriggerEmoteRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<TriggerEmoteRequest>, I>>(object: I): TriggerEmoteRequest {
+    const message = createBaseTriggerEmoteRequest();
+    message.predefinedEmote = object.predefinedEmote ?? "";
+    message.mask = object.mask ?? undefined;
+    return message;
+  }
+}
+
+function createBaseChangeRealmRequest(): ChangeRealmRequest {
+  return { realm: "", message: undefined };
+}
+
+export namespace ChangeRealmRequest {
+  export function encode(message: ChangeRealmRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.realm !== "") {
+      writer.uint32(10).string(message.realm);
+    }
+    if (message.message !== undefined) {
+      writer.uint32(18).string(message.message);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ChangeRealmRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseChangeRealmRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.realm = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ChangeRealmRequest {
+    return {
+      realm: isSet(object.realm) ? String(object.realm) : "",
+      message: isSet(object.message) ? String(object.message) : undefined,
+    };
+  }
+
+  export function toJSON(message: ChangeRealmRequest): unknown {
+    const obj: any = {};
+    message.realm !== undefined && (obj.realm = message.realm);
+    message.message !== undefined && (obj.message = message.message);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ChangeRealmRequest>, I>>(base?: I): ChangeRealmRequest {
+    return ChangeRealmRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ChangeRealmRequest>, I>>(object: I): ChangeRealmRequest {
+    const message = createBaseChangeRealmRequest();
+    message.realm = object.realm ?? "";
+    message.message = object.message ?? undefined;
+    return message;
+  }
+}
+
+function createBaseOpenExternalUrlRequest(): OpenExternalUrlRequest {
+  return { url: "" };
+}
+
+export namespace OpenExternalUrlRequest {
+  export function encode(message: OpenExternalUrlRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.url !== "") {
+      writer.uint32(10).string(message.url);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): OpenExternalUrlRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOpenExternalUrlRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.url = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): OpenExternalUrlRequest {
+    return { url: isSet(object.url) ? String(object.url) : "" };
+  }
+
+  export function toJSON(message: OpenExternalUrlRequest): unknown {
+    const obj: any = {};
+    message.url !== undefined && (obj.url = message.url);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<OpenExternalUrlRequest>, I>>(base?: I): OpenExternalUrlRequest {
+    return OpenExternalUrlRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<OpenExternalUrlRequest>, I>>(
+    object: I,
+  ): OpenExternalUrlRequest {
+    const message = createBaseOpenExternalUrlRequest();
+    message.url = object.url ?? "";
+    return message;
+  }
+}
+
+function createBaseOpenNftDialogRequest(): OpenNftDialogRequest {
+  return { urn: "" };
+}
+
+export namespace OpenNftDialogRequest {
+  export function encode(message: OpenNftDialogRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.urn !== "") {
+      writer.uint32(10).string(message.urn);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): OpenNftDialogRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOpenNftDialogRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.urn = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): OpenNftDialogRequest {
+    return { urn: isSet(object.urn) ? String(object.urn) : "" };
+  }
+
+  export function toJSON(message: OpenNftDialogRequest): unknown {
+    const obj: any = {};
+    message.urn !== undefined && (obj.urn = message.urn);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<OpenNftDialogRequest>, I>>(base?: I): OpenNftDialogRequest {
+    return OpenNftDialogRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<OpenNftDialogRequest>, I>>(object: I): OpenNftDialogRequest {
+    const message = createBaseOpenNftDialogRequest();
+    message.urn = object.urn ?? "";
+    return message;
+  }
+}
+
+function createBaseUnblockPointerRequest(): UnblockPointerRequest {
+  return {};
+}
+
+export namespace UnblockPointerRequest {
+  export function encode(_: UnblockPointerRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UnblockPointerRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUnblockPointerRequest();
+    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): UnblockPointerRequest {
+    return {};
+  }
+
+  export function toJSON(_: UnblockPointerRequest): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<UnblockPointerRequest>, I>>(base?: I): UnblockPointerRequest {
+    return UnblockPointerRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UnblockPointerRequest>, I>>(_: I): UnblockPointerRequest {
+    const message = createBaseUnblockPointerRequest();
+    return message;
+  }
+}
+
+function createBaseCommsAdapterRequest(): CommsAdapterRequest {
+  return { connectionString: "" };
+}
+
+export namespace CommsAdapterRequest {
+  export function encode(message: CommsAdapterRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.connectionString !== "") {
+      writer.uint32(10).string(message.connectionString);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CommsAdapterRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCommsAdapterRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.connectionString = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): CommsAdapterRequest {
+    return { connectionString: isSet(object.connectionString) ? String(object.connectionString) : "" };
+  }
+
+  export function toJSON(message: CommsAdapterRequest): unknown {
+    const obj: any = {};
+    message.connectionString !== undefined && (obj.connectionString = message.connectionString);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CommsAdapterRequest>, I>>(base?: I): CommsAdapterRequest {
+    return CommsAdapterRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CommsAdapterRequest>, I>>(object: I): CommsAdapterRequest {
+    const message = createBaseCommsAdapterRequest();
+    message.connectionString = object.connectionString ?? "";
+    return message;
+  }
+}
+
+function createBaseTriggerSceneEmoteRequest(): TriggerSceneEmoteRequest {
+  return { src: "", loop: undefined, mask: undefined };
+}
+
+export namespace TriggerSceneEmoteRequest {
+  export function encode(message: TriggerSceneEmoteRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.src !== "") {
+      writer.uint32(10).string(message.src);
+    }
+    if (message.loop !== undefined) {
+      writer.uint32(16).bool(message.loop);
+    }
+    if (message.mask !== undefined) {
+      writer.uint32(24).int32(message.mask);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): TriggerSceneEmoteRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTriggerSceneEmoteRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.src = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.loop = reader.bool();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.mask = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): TriggerSceneEmoteRequest {
+    return {
+      src: isSet(object.src) ? String(object.src) : "",
+      loop: isSet(object.loop) ? Boolean(object.loop) : undefined,
+      mask: isSet(object.mask) ? avatarMaskFromJSON(object.mask) : undefined,
+    };
+  }
+
+  export function toJSON(message: TriggerSceneEmoteRequest): unknown {
+    const obj: any = {};
+    message.src !== undefined && (obj.src = message.src);
+    message.loop !== undefined && (obj.loop = message.loop);
+    message.mask !== undefined && (obj.mask = message.mask !== undefined ? avatarMaskToJSON(message.mask) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<TriggerSceneEmoteRequest>, I>>(
+    base?: I,
+  ): TriggerSceneEmoteRequest {
+    return TriggerSceneEmoteRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<TriggerSceneEmoteRequest>, I>>(
+    object: I,
+  ): TriggerSceneEmoteRequest {
+    const message = createBaseTriggerSceneEmoteRequest();
+    message.src = object.src ?? "";
+    message.loop = object.loop ?? undefined;
+    message.mask = object.mask ?? undefined;
+    return message;
+  }
+}
+
+function createBaseSuccessResponse(): SuccessResponse {
+  return { success: false };
+}
+
+export namespace SuccessResponse {
+  export function encode(message: SuccessResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.success === true) {
+      writer.uint32(8).bool(message.success);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SuccessResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSuccessResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.success = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): SuccessResponse {
+    return { success: isSet(object.success) ? Boolean(object.success) : false };
+  }
+
+  export function toJSON(message: SuccessResponse): unknown {
+    const obj: any = {};
+    message.success !== undefined && (obj.success = message.success);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SuccessResponse>, I>>(base?: I): SuccessResponse {
+    return SuccessResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SuccessResponse>, I>>(object: I): SuccessResponse {
+    const message = createBaseSuccessResponse();
+    message.success = object.success ?? false;
+    return message;
+  }
+}
+
+function createBaseTriggerEmoteResponse(): TriggerEmoteResponse {
+  return {};
+}
+
+export namespace TriggerEmoteResponse {
+  export function encode(_: TriggerEmoteResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): TriggerEmoteResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTriggerEmoteResponse();
+    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): TriggerEmoteResponse {
+    return {};
+  }
+
+  export function toJSON(_: TriggerEmoteResponse): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<TriggerEmoteResponse>, I>>(base?: I): TriggerEmoteResponse {
+    return TriggerEmoteResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<TriggerEmoteResponse>, I>>(_: I): TriggerEmoteResponse {
+    const message = createBaseTriggerEmoteResponse();
+    return message;
+  }
+}
+
+function createBaseMovePlayerToResponse(): MovePlayerToResponse {
+  return { success: false };
+}
+
+export namespace MovePlayerToResponse {
+  export function encode(message: MovePlayerToResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.success === true) {
+      writer.uint32(8).bool(message.success);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): MovePlayerToResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMovePlayerToResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.success = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): MovePlayerToResponse {
+    return { success: isSet(object.success) ? Boolean(object.success) : false };
+  }
+
+  export function toJSON(message: MovePlayerToResponse): unknown {
+    const obj: any = {};
+    message.success !== undefined && (obj.success = message.success);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<MovePlayerToResponse>, I>>(base?: I): MovePlayerToResponse {
+    return MovePlayerToResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<MovePlayerToResponse>, I>>(object: I): MovePlayerToResponse {
+    const message = createBaseMovePlayerToResponse();
+    message.success = object.success ?? false;
+    return message;
+  }
+}
+
+function createBaseWalkPlayerToRequest(): WalkPlayerToRequest {
+  return { newRelativePosition: undefined, stopThreshold: 0, timeout: undefined };
+}
+
+export namespace WalkPlayerToRequest {
+  export function encode(message: WalkPlayerToRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.newRelativePosition !== undefined) {
+      Vector3.encode(message.newRelativePosition, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.stopThreshold !== 0) {
+      writer.uint32(21).float(message.stopThreshold);
+    }
+    if (message.timeout !== undefined) {
+      writer.uint32(29).float(message.timeout);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WalkPlayerToRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWalkPlayerToRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.newRelativePosition = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 21) {
+            break;
+          }
+
+          message.stopThreshold = reader.float();
+          continue;
+        case 3:
+          if (tag !== 29) {
+            break;
+          }
+
+          message.timeout = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WalkPlayerToRequest {
+    return {
+      newRelativePosition: isSet(object.newRelativePosition) ? Vector3.fromJSON(object.newRelativePosition) : undefined,
+      stopThreshold: isSet(object.stopThreshold) ? Number(object.stopThreshold) : 0,
+      timeout: isSet(object.timeout) ? Number(object.timeout) : undefined,
+    };
+  }
+
+  export function toJSON(message: WalkPlayerToRequest): unknown {
+    const obj: any = {};
+    message.newRelativePosition !== undefined &&
+      (obj.newRelativePosition = message.newRelativePosition ? Vector3.toJSON(message.newRelativePosition) : undefined);
+    message.stopThreshold !== undefined && (obj.stopThreshold = message.stopThreshold);
+    message.timeout !== undefined && (obj.timeout = message.timeout);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WalkPlayerToRequest>, I>>(base?: I): WalkPlayerToRequest {
+    return WalkPlayerToRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WalkPlayerToRequest>, I>>(object: I): WalkPlayerToRequest {
+    const message = createBaseWalkPlayerToRequest();
+    message.newRelativePosition = (object.newRelativePosition !== undefined && object.newRelativePosition !== null)
+      ? Vector3.fromPartial(object.newRelativePosition)
+      : undefined;
+    message.stopThreshold = object.stopThreshold ?? 0;
+    message.timeout = object.timeout ?? undefined;
+    return message;
+  }
+}
+
+function createBaseWalkPlayerToResponse(): WalkPlayerToResponse {
+  return { success: false };
+}
+
+export namespace WalkPlayerToResponse {
+  export function encode(message: WalkPlayerToResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.success === true) {
+      writer.uint32(8).bool(message.success);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): WalkPlayerToResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseWalkPlayerToResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.success = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): WalkPlayerToResponse {
+    return { success: isSet(object.success) ? Boolean(object.success) : false };
+  }
+
+  export function toJSON(message: WalkPlayerToResponse): unknown {
+    const obj: any = {};
+    message.success !== undefined && (obj.success = message.success);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<WalkPlayerToResponse>, I>>(base?: I): WalkPlayerToResponse {
+    return WalkPlayerToResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<WalkPlayerToResponse>, I>>(object: I): WalkPlayerToResponse {
+    const message = createBaseWalkPlayerToResponse();
+    message.success = object.success ?? false;
+    return message;
+  }
 }
 
-export interface TriggerEmoteResponse {
+function createBaseTeleportToResponse(): TeleportToResponse {
+  return {};
 }
 
-export interface TriggerEmoteRequest {
-  predefinedEmote: string;
+export namespace TeleportToResponse {
+  export function encode(_: TeleportToResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): TeleportToResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTeleportToResponse();
+    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): TeleportToResponse {
+    return {};
+  }
+
+  export function toJSON(_: TeleportToResponse): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<TeleportToResponse>, I>>(base?: I): TeleportToResponse {
+    return TeleportToResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<TeleportToResponse>, I>>(_: I): TeleportToResponse {
+    const message = createBaseTeleportToResponse();
+    return message;
+  }
 }
 
-function createBaseVector3(): Vector3 {
-  return { x: 0, y: 0, z: 0 };
+function createBaseSetUiFocusRequest(): SetUiFocusRequest {
+  return { elementId: "" };
 }
 
-export const Vector3 = {
-  encode(message: Vector3, 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);
+export namespace SetUiFocusRequest {
+  export function encode(message: SetUiFocusRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.elementId !== "") {
+      writer.uint32(10).string(message.elementId);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Vector3 {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SetUiFocusRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseVector3();
+    const message = createBaseSetUiFocusRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.x = reader.float();
-          break;
-        case 2:
-          message.y = reader.float();
-          break;
-        case 3:
-          message.z = reader.float();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          if (tag !== 10) {
+            break;
+          }
+
+          message.elementId = reader.string();
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): Vector3 {
-    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 fromJSON(object: any): SetUiFocusRequest {
+    return { elementId: isSet(object.elementId) ? String(object.elementId) : "" };
+  }
 
-  toJSON(message: Vector3): unknown {
+  export function toJSON(message: SetUiFocusRequest): 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.elementId !== undefined && (obj.elementId = message.elementId);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<Vector3>, I>>(object: I): Vector3 {
-    const message = createBaseVector3();
-    message.x = object.x ?? 0;
-    message.y = object.y ?? 0;
-    message.z = object.z ?? 0;
+  export function create<I extends Exact<DeepPartial<SetUiFocusRequest>, I>>(base?: I): SetUiFocusRequest {
+    return SetUiFocusRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SetUiFocusRequest>, I>>(object: I): SetUiFocusRequest {
+    const message = createBaseSetUiFocusRequest();
+    message.elementId = object.elementId ?? "";
     return message;
-  },
-};
+  }
+}
 
-function createBaseMovePlayerToResponse(): MovePlayerToResponse {
+function createBaseClearUiFocusRequest(): ClearUiFocusRequest {
   return {};
 }
 
-export const MovePlayerToResponse = {
-  encode(_: MovePlayerToResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace ClearUiFocusRequest {
+  export function encode(_: ClearUiFocusRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): MovePlayerToResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ClearUiFocusRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseMovePlayerToResponse();
+    const message = createBaseClearUiFocusRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        default:
-          reader.skipType(tag & 7);
-          break;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(_: any): MovePlayerToResponse {
+  export function fromJSON(_: any): ClearUiFocusRequest {
     return {};
-  },
+  }
 
-  toJSON(_: MovePlayerToResponse): unknown {
+  export function toJSON(_: ClearUiFocusRequest): unknown {
     const obj: any = {};
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<MovePlayerToResponse>, I>>(_: I): MovePlayerToResponse {
-    const message = createBaseMovePlayerToResponse();
+  export function create<I extends Exact<DeepPartial<ClearUiFocusRequest>, I>>(base?: I): ClearUiFocusRequest {
+    return ClearUiFocusRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ClearUiFocusRequest>, I>>(_: I): ClearUiFocusRequest {
+    const message = createBaseClearUiFocusRequest();
     return message;
-  },
-};
+  }
+}
 
-function createBaseMovePlayerToRequest(): MovePlayerToRequest {
-  return { newRelativePosition: undefined, cameraTarget: undefined };
+function createBaseGetUiFocusRequest(): GetUiFocusRequest {
+  return {};
 }
 
-export const MovePlayerToRequest = {
-  encode(message: MovePlayerToRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.newRelativePosition !== undefined) {
-      Vector3.encode(message.newRelativePosition, writer.uint32(10).fork()).ldelim();
+export namespace GetUiFocusRequest {
+  export function encode(_: GetUiFocusRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetUiFocusRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetUiFocusRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
-    if (message.cameraTarget !== undefined) {
-      Vector3.encode(message.cameraTarget, writer.uint32(18).fork()).ldelim();
+    return message;
+  }
+
+  export function fromJSON(_: any): GetUiFocusRequest {
+    return {};
+  }
+
+  export function toJSON(_: GetUiFocusRequest): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<GetUiFocusRequest>, I>>(base?: I): GetUiFocusRequest {
+    return GetUiFocusRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<GetUiFocusRequest>, I>>(_: I): GetUiFocusRequest {
+    const message = createBaseGetUiFocusRequest();
+    return message;
+  }
+}
+
+function createBaseUiFocusResponse(): UiFocusResponse {
+  return { elementId: undefined };
+}
+
+export namespace UiFocusResponse {
+  export function encode(message: UiFocusResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.elementId !== undefined) {
+      writer.uint32(10).string(message.elementId);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): MovePlayerToRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): UiFocusResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseMovePlayerToRequest();
+    const message = createBaseUiFocusResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.newRelativePosition = Vector3.decode(reader, reader.uint32());
-          break;
-        case 2:
-          message.cameraTarget = Vector3.decode(reader, reader.uint32());
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          if (tag !== 10) {
+            break;
+          }
+
+          message.elementId = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): MovePlayerToRequest {
-    return {
-      newRelativePosition: isSet(object.newRelativePosition) ? Vector3.fromJSON(object.newRelativePosition) : undefined,
-      cameraTarget: isSet(object.cameraTarget) ? Vector3.fromJSON(object.cameraTarget) : undefined,
-    };
-  },
+  export function fromJSON(object: any): UiFocusResponse {
+    return { elementId: isSet(object.elementId) ? String(object.elementId) : undefined };
+  }
 
-  toJSON(message: MovePlayerToRequest): unknown {
+  export function toJSON(message: UiFocusResponse): unknown {
     const obj: any = {};
-    message.newRelativePosition !== undefined &&
-      (obj.newRelativePosition = message.newRelativePosition ? Vector3.toJSON(message.newRelativePosition) : undefined);
-    message.cameraTarget !== undefined &&
-      (obj.cameraTarget = message.cameraTarget ? Vector3.toJSON(message.cameraTarget) : undefined);
+    message.elementId !== undefined && (obj.elementId = message.elementId);
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<MovePlayerToRequest>, I>>(object: I): MovePlayerToRequest {
-    const message = createBaseMovePlayerToRequest();
-    message.newRelativePosition = (object.newRelativePosition !== undefined && object.newRelativePosition !== null)
-      ? Vector3.fromPartial(object.newRelativePosition)
-      : undefined;
-    message.cameraTarget = (object.cameraTarget !== undefined && object.cameraTarget !== null)
-      ? Vector3.fromPartial(object.cameraTarget)
-      : undefined;
+  export function create<I extends Exact<DeepPartial<UiFocusResponse>, I>>(base?: I): UiFocusResponse {
+    return UiFocusResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<UiFocusResponse>, I>>(object: I): UiFocusResponse {
+    const message = createBaseUiFocusResponse();
+    message.elementId = object.elementId ?? undefined;
     return message;
-  },
-};
+  }
+}
 
-function createBaseTriggerEmoteResponse(): TriggerEmoteResponse {
+function createBaseCopyToClipboardRequest(): CopyToClipboardRequest {
+  return { text: "" };
+}
+
+export namespace CopyToClipboardRequest {
+  export function encode(message: CopyToClipboardRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.text !== "") {
+      writer.uint32(10).string(message.text);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CopyToClipboardRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCopyToClipboardRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.text = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): CopyToClipboardRequest {
+    return { text: isSet(object.text) ? String(object.text) : "" };
+  }
+
+  export function toJSON(message: CopyToClipboardRequest): unknown {
+    const obj: any = {};
+    message.text !== undefined && (obj.text = message.text);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CopyToClipboardRequest>, I>>(base?: I): CopyToClipboardRequest {
+    return CopyToClipboardRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CopyToClipboardRequest>, I>>(
+    object: I,
+  ): CopyToClipboardRequest {
+    const message = createBaseCopyToClipboardRequest();
+    message.text = object.text ?? "";
+    return message;
+  }
+}
+
+function createBaseEmptyResponse(): EmptyResponse {
   return {};
 }
 
-export const TriggerEmoteResponse = {
-  encode(_: TriggerEmoteResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace EmptyResponse {
+  export function encode(_: EmptyResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TriggerEmoteResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): EmptyResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTriggerEmoteResponse();
+    const message = createBaseEmptyResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        default:
-          reader.skipType(tag & 7);
-          break;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(_: any): TriggerEmoteResponse {
+  export function fromJSON(_: any): EmptyResponse {
     return {};
-  },
+  }
 
-  toJSON(_: TriggerEmoteResponse): unknown {
+  export function toJSON(_: EmptyResponse): unknown {
     const obj: any = {};
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<TriggerEmoteResponse>, I>>(_: I): TriggerEmoteResponse {
-    const message = createBaseTriggerEmoteResponse();
+  export function create<I extends Exact<DeepPartial<EmptyResponse>, I>>(base?: I): EmptyResponse {
+    return EmptyResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<EmptyResponse>, I>>(_: I): EmptyResponse {
+    const message = createBaseEmptyResponse();
     return message;
-  },
-};
+  }
+}
 
-function createBaseTriggerEmoteRequest(): TriggerEmoteRequest {
-  return { predefinedEmote: "" };
+function createBaseStopEmoteRequest(): StopEmoteRequest {
+  return {};
 }
 
-export const TriggerEmoteRequest = {
-  encode(message: TriggerEmoteRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.predefinedEmote !== "") {
-      writer.uint32(10).string(message.predefinedEmote);
+export namespace StopEmoteRequest {
+  export function encode(_: StopEmoteRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): StopEmoteRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStopEmoteRequest();
+    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): StopEmoteRequest {
+    return {};
+  }
+
+  export function toJSON(_: StopEmoteRequest): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<StopEmoteRequest>, I>>(base?: I): StopEmoteRequest {
+    return StopEmoteRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<StopEmoteRequest>, I>>(_: I): StopEmoteRequest {
+    const message = createBaseStopEmoteRequest();
+    return message;
+  }
+}
+
+function createBaseOpenExplorerUiRequest(): OpenExplorerUiRequest {
+  return { ui: 0 };
+}
+
+export namespace OpenExplorerUiRequest {
+  export function encode(message: OpenExplorerUiRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.ui !== 0) {
+      writer.uint32(8).int32(message.ui);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): TriggerEmoteRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): OpenExplorerUiRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTriggerEmoteRequest();
+    const message = createBaseOpenExplorerUiRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.predefinedEmote = reader.string();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          if (tag !== 8) {
+            break;
+          }
+
+          message.ui = reader.int32() as any;
+          continue;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): TriggerEmoteRequest {
-    return { predefinedEmote: isSet(object.predefinedEmote) ? String(object.predefinedEmote) : "" };
-  },
+  export function fromJSON(object: any): OpenExplorerUiRequest {
+    return { ui: isSet(object.ui) ? explorerUiFromJSON(object.ui) : 0 };
+  }
 
-  toJSON(message: TriggerEmoteRequest): unknown {
+  export function toJSON(message: OpenExplorerUiRequest): unknown {
     const obj: any = {};
-    message.predefinedEmote !== undefined && (obj.predefinedEmote = message.predefinedEmote);
+    message.ui !== undefined && (obj.ui = explorerUiToJSON(message.ui));
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<TriggerEmoteRequest>, I>>(object: I): TriggerEmoteRequest {
-    const message = createBaseTriggerEmoteRequest();
-    message.predefinedEmote = object.predefinedEmote ?? "";
+  export function create<I extends Exact<DeepPartial<OpenExplorerUiRequest>, I>>(base?: I): OpenExplorerUiRequest {
+    return OpenExplorerUiRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<OpenExplorerUiRequest>, I>>(
+    object: I,
+  ): OpenExplorerUiRequest {
+    const message = createBaseOpenExplorerUiRequest();
+    message.ui = object.ui ?? 0;
     return message;
-  },
-};
+  }
+}
+
+function createBaseOpenExplorerUiResponse(): OpenExplorerUiResponse {
+  return { openResult: 0 };
+}
+
+export namespace OpenExplorerUiResponse {
+  export function encode(message: OpenExplorerUiResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.openResult !== 0) {
+      writer.uint32(8).int32(message.openResult);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): OpenExplorerUiResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOpenExplorerUiResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.openResult = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): OpenExplorerUiResponse {
+    return { openResult: isSet(object.openResult) ? openExplorerUiResultFromJSON(object.openResult) : 0 };
+  }
+
+  export function toJSON(message: OpenExplorerUiResponse): unknown {
+    const obj: any = {};
+    message.openResult !== undefined && (obj.openResult = openExplorerUiResultToJSON(message.openResult));
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<OpenExplorerUiResponse>, I>>(base?: I): OpenExplorerUiResponse {
+    return OpenExplorerUiResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<OpenExplorerUiResponse>, I>>(
+    object: I,
+  ): OpenExplorerUiResponse {
+    const message = createBaseOpenExplorerUiResponse();
+    message.openResult = object.openResult ?? 0;
+    return message;
+  }
+}
 
 export type RestrictedActionsServiceDefinition = typeof RestrictedActionsServiceDefinition;
 export const RestrictedActionsServiceDefinition = {
   name: "RestrictedActionsService",
   fullName: "decentraland.kernel.apis.RestrictedActionsService",
   methods: {
+    /**
+     * MovePlayerTo will move the player to a position relative to the current scene.
+     * If 'duration' field is used in the request, the success response depends on the
+     * whole interpolation being completed or interrupted (e.g: by input movement)
+     */
     movePlayerTo: {
       name: "MovePlayerTo",
       requestType: MovePlayerToRequest,
@@ -293,6 +1628,30 @@ export const RestrictedActionsServiceDefinition = {
       responseStream: false,
       options: {},
     },
+    /**
+     * TeleportTo will move the user to the specified world LAND parcel coordinates
+     * WalkPlayerTo will walk the player to a position relative to the current scene,
+     * managed by the movement controller scene. Returns success when the player reaches
+     * within stop_threshold distance, or false if the path is blocked, the player gets
+     * stuck, the player interrupts the walk with manual input, or the optional timeout expires.
+     */
+    walkPlayerTo: {
+      name: "WalkPlayerTo",
+      requestType: WalkPlayerToRequest,
+      requestStream: false,
+      responseType: WalkPlayerToResponse,
+      responseStream: false,
+      options: {},
+    },
+    teleportTo: {
+      name: "TeleportTo",
+      requestType: TeleportToRequest,
+      requestStream: false,
+      responseType: TeleportToResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** TriggerEmote will trigger an emote in this current user */
     triggerEmote: {
       name: "TriggerEmote",
       requestType: TriggerEmoteRequest,
@@ -301,6 +1660,113 @@ export const RestrictedActionsServiceDefinition = {
       responseStream: false,
       options: {},
     },
+    /**
+     * @deprecated, use TeleportTo with `realm` (and no `world_coordinates` for the realm's default spawn)
+     * ChangeRealm prompts the user to change to a specific realm
+     */
+    changeRealm: {
+      name: "ChangeRealm",
+      requestType: ChangeRealmRequest,
+      requestStream: false,
+      responseType: SuccessResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** OpenExternalUrl prompts the user to open an external link */
+    openExternalUrl: {
+      name: "OpenExternalUrl",
+      requestType: OpenExternalUrlRequest,
+      requestStream: false,
+      responseType: SuccessResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** OpenNftDialog opens an NFT dialog. */
+    openNftDialog: {
+      name: "OpenNftDialog",
+      requestType: OpenNftDialogRequest,
+      requestStream: false,
+      responseType: SuccessResponse,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * Asks the explorer to connect to other communications adapter, this feature
+     * can be used to join private game servers
+     */
+    setCommunicationsAdapter: {
+      name: "SetCommunicationsAdapter",
+      requestType: CommsAdapterRequest,
+      requestStream: false,
+      responseType: SuccessResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** TriggerSceneEmote will trigger an scene emote file in this current user */
+    triggerSceneEmote: {
+      name: "TriggerSceneEmote",
+      requestType: TriggerSceneEmoteRequest,
+      requestStream: false,
+      responseType: SuccessResponse,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * CopyToClipboard copies the provided text into the clipboard
+     * Sets the focus to a specific UI element
+     */
+    setUiFocus: {
+      name: "SetUiFocus",
+      requestType: SetUiFocusRequest,
+      requestStream: false,
+      responseType: UiFocusResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Clears the focus from any currently focused textentry or dropdown */
+    clearUiFocus: {
+      name: "ClearUiFocus",
+      requestType: ClearUiFocusRequest,
+      requestStream: false,
+      responseType: UiFocusResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Returns the element_id of any currently focused textentry or dropdown */
+    getUiFocus: {
+      name: "GetUiFocus",
+      requestType: GetUiFocusRequest,
+      requestStream: false,
+      responseType: UiFocusResponse,
+      responseStream: false,
+      options: {},
+    },
+    copyToClipboard: {
+      name: "CopyToClipboard",
+      requestType: CopyToClipboardRequest,
+      requestStream: false,
+      responseType: EmptyResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** StopEmote will stop the current emote */
+    stopEmote: {
+      name: "StopEmote",
+      requestType: StopEmoteRequest,
+      requestStream: false,
+      responseType: SuccessResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** OpenExplorerUi opens a specific fullscreen explorer panel and returns the open verdict. */
+    openExplorerUi: {
+      name: "OpenExplorerUi",
+      requestType: OpenExplorerUiRequest,
+      requestStream: false,
+      responseType: OpenExplorerUiResponse,
+      responseStream: false,
+      options: {},
+    },
   },
 } as const;