@dcl/protocol 1.0.0-3939040004.commit-2c2721f → 1.0.0-39771882714.commit-70f2654

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

@@ -1,17 +1,12 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
+import { ContentMapping } from "../../common/content_mapping.gen";
+import { PBRealmInfo } from "../../sdk/components/realm_info.gen";
 
 export const protobufPackage = "decentraland.kernel.apis";
 
-export interface RealmInfo {
-  baseUrl: string;
-  realmName: string;
-  networkId: number;
-  commsAdapter: string;
-}
-
 export interface GetRealmResponse {
-  realmInfo?: RealmInfo | undefined;
+  realmInfo?: PBRealmInfo | undefined;
 }
 
 export interface GetWorldTimeResponse {
@@ -24,282 +19,778 @@ export interface GetRealmRequest {
 export interface GetWorldTimeRequest {
 }
 
-function createBaseRealmInfo(): RealmInfo {
-  return { baseUrl: "", realmName: "", networkId: 0, commsAdapter: "" };
+export interface ReadFileRequest {
+  /** name of the deployed file */
+  fileName: string;
 }
 
-export const RealmInfo = {
-  encode(message: RealmInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
-    if (message.baseUrl !== "") {
-      writer.uint32(10).string(message.baseUrl);
-    }
-    if (message.realmName !== "") {
-      writer.uint32(18).string(message.realmName);
-    }
-    if (message.networkId !== 0) {
-      writer.uint32(24).int32(message.networkId);
-    }
-    if (message.commsAdapter !== "") {
-      writer.uint32(34).string(message.commsAdapter);
-    }
-    return writer;
-  },
+export interface ReadFileResponse {
+  /** contents of the file */
+  content: Uint8Array;
+  /** deployed hash/CID */
+  hash: string;
+}
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): RealmInfo {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseRealmInfo();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1:
-          message.baseUrl = reader.string();
-          break;
-        case 2:
-          message.realmName = reader.string();
-          break;
-        case 3:
-          message.networkId = reader.int32();
-          break;
-        case 4:
-          message.commsAdapter = reader.string();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
-      }
-    }
-    return message;
-  },
+export interface CurrentSceneEntityRequest {
+}
 
-  fromJSON(object: any): RealmInfo {
-    return {
-      baseUrl: isSet(object.baseUrl) ? String(object.baseUrl) : "",
-      realmName: isSet(object.realmName) ? String(object.realmName) : "",
-      networkId: isSet(object.networkId) ? Number(object.networkId) : 0,
-      commsAdapter: isSet(object.commsAdapter) ? String(object.commsAdapter) : "",
-    };
-  },
+export interface CurrentSceneEntityResponse {
+  /** this is either the entityId or the full URN of the scene that is running */
+  urn: string;
+  /** contents of the deployed entities */
+  content: ContentMapping[];
+  /** JSON serialization of the entity.metadata field */
+  metadataJson: string;
+  /** baseUrl used to resolve all content files */
+  baseUrl: string;
+}
 
-  toJSON(message: RealmInfo): unknown {
-    const obj: any = {};
-    message.baseUrl !== undefined && (obj.baseUrl = message.baseUrl);
-    message.realmName !== undefined && (obj.realmName = message.realmName);
-    message.networkId !== undefined && (obj.networkId = Math.round(message.networkId));
-    message.commsAdapter !== undefined && (obj.commsAdapter = message.commsAdapter);
-    return obj;
-  },
+export interface GetExplorerInformationRequest {
+}
 
-  create<I extends Exact<DeepPartial<RealmInfo>, I>>(base?: I): RealmInfo {
-    return RealmInfo.fromPartial(base ?? {});
-  },
+export interface GetExplorerInformationResponse {
+  /** the agent that current explorer is identified as */
+  agent: string;
+  /** options: "desktop", "mobile", "vr", "web" */
+  platform: string;
+  /** custom configurations set in the explorer */
+  configurations: { [key: string]: string };
+}
 
-  fromPartial<I extends Exact<DeepPartial<RealmInfo>, I>>(object: I): RealmInfo {
-    const message = createBaseRealmInfo();
-    message.baseUrl = object.baseUrl ?? "";
-    message.realmName = object.realmName ?? "";
-    message.networkId = object.networkId ?? 0;
-    message.commsAdapter = object.commsAdapter ?? "";
-    return message;
-  },
-};
+export interface GetExplorerInformationResponse_ConfigurationsEntry {
+  key: string;
+  value: string;
+}
 
 function createBaseGetRealmResponse(): GetRealmResponse {
   return { realmInfo: undefined };
 }
 
-export const GetRealmResponse = {
-  encode(message: GetRealmResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace GetRealmResponse {
+  export function encode(message: GetRealmResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.realmInfo !== undefined) {
-      RealmInfo.encode(message.realmInfo, writer.uint32(10).fork()).ldelim();
+      PBRealmInfo.encode(message.realmInfo, writer.uint32(10).fork()).ldelim();
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): GetRealmResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetRealmResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetRealmResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          message.realmInfo = RealmInfo.decode(reader, reader.uint32());
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          if (tag !== 10) {
+            break;
+          }
+
+          message.realmInfo = PBRealmInfo.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): GetRealmResponse {
-    return { realmInfo: isSet(object.realmInfo) ? RealmInfo.fromJSON(object.realmInfo) : undefined };
-  },
+  export function fromJSON(object: any): GetRealmResponse {
+    return { realmInfo: isSet(object.realmInfo) ? PBRealmInfo.fromJSON(object.realmInfo) : undefined };
+  }
 
-  toJSON(message: GetRealmResponse): unknown {
+  export function toJSON(message: GetRealmResponse): unknown {
     const obj: any = {};
     message.realmInfo !== undefined &&
-      (obj.realmInfo = message.realmInfo ? RealmInfo.toJSON(message.realmInfo) : undefined);
+      (obj.realmInfo = message.realmInfo ? PBRealmInfo.toJSON(message.realmInfo) : undefined);
     return obj;
-  },
+  }
 
-  create<I extends Exact<DeepPartial<GetRealmResponse>, I>>(base?: I): GetRealmResponse {
+  export function create<I extends Exact<DeepPartial<GetRealmResponse>, I>>(base?: I): GetRealmResponse {
     return GetRealmResponse.fromPartial(base ?? {});
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<GetRealmResponse>, I>>(object: I): GetRealmResponse {
+  export function fromPartial<I extends Exact<DeepPartial<GetRealmResponse>, I>>(object: I): GetRealmResponse {
     const message = createBaseGetRealmResponse();
     message.realmInfo = (object.realmInfo !== undefined && object.realmInfo !== null)
-      ? RealmInfo.fromPartial(object.realmInfo)
+      ? PBRealmInfo.fromPartial(object.realmInfo)
       : undefined;
     return message;
-  },
-};
+  }
+}
 
 function createBaseGetWorldTimeResponse(): GetWorldTimeResponse {
   return { seconds: 0 };
 }
 
-export const GetWorldTimeResponse = {
-  encode(message: GetWorldTimeResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace GetWorldTimeResponse {
+  export function encode(message: GetWorldTimeResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.seconds !== 0) {
       writer.uint32(8).int32(message.seconds);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): GetWorldTimeResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetWorldTimeResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetWorldTimeResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 8) {
+            break;
+          }
+
           message.seconds = reader.int32();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): GetWorldTimeResponse {
+  export function fromJSON(object: any): GetWorldTimeResponse {
     return { seconds: isSet(object.seconds) ? Number(object.seconds) : 0 };
-  },
+  }
 
-  toJSON(message: GetWorldTimeResponse): unknown {
+  export function toJSON(message: GetWorldTimeResponse): unknown {
     const obj: any = {};
     message.seconds !== undefined && (obj.seconds = Math.round(message.seconds));
     return obj;
-  },
+  }
 
-  create<I extends Exact<DeepPartial<GetWorldTimeResponse>, I>>(base?: I): GetWorldTimeResponse {
+  export function create<I extends Exact<DeepPartial<GetWorldTimeResponse>, I>>(base?: I): GetWorldTimeResponse {
     return GetWorldTimeResponse.fromPartial(base ?? {});
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<GetWorldTimeResponse>, I>>(object: I): GetWorldTimeResponse {
+  export function fromPartial<I extends Exact<DeepPartial<GetWorldTimeResponse>, I>>(object: I): GetWorldTimeResponse {
     const message = createBaseGetWorldTimeResponse();
     message.seconds = object.seconds ?? 0;
     return message;
-  },
-};
+  }
+}
 
 function createBaseGetRealmRequest(): GetRealmRequest {
   return {};
 }
 
-export const GetRealmRequest = {
-  encode(_: GetRealmRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace GetRealmRequest {
+  export function encode(_: GetRealmRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): GetRealmRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetRealmRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetRealmRequest();
     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): GetRealmRequest {
+  export function fromJSON(_: any): GetRealmRequest {
     return {};
-  },
+  }
 
-  toJSON(_: GetRealmRequest): unknown {
+  export function toJSON(_: GetRealmRequest): unknown {
     const obj: any = {};
     return obj;
-  },
+  }
 
-  create<I extends Exact<DeepPartial<GetRealmRequest>, I>>(base?: I): GetRealmRequest {
+  export function create<I extends Exact<DeepPartial<GetRealmRequest>, I>>(base?: I): GetRealmRequest {
     return GetRealmRequest.fromPartial(base ?? {});
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<GetRealmRequest>, I>>(_: I): GetRealmRequest {
+  export function fromPartial<I extends Exact<DeepPartial<GetRealmRequest>, I>>(_: I): GetRealmRequest {
     const message = createBaseGetRealmRequest();
     return message;
-  },
-};
+  }
+}
 
 function createBaseGetWorldTimeRequest(): GetWorldTimeRequest {
   return {};
 }
 
-export const GetWorldTimeRequest = {
-  encode(_: GetWorldTimeRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace GetWorldTimeRequest {
+  export function encode(_: GetWorldTimeRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): GetWorldTimeRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetWorldTimeRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetWorldTimeRequest();
     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): GetWorldTimeRequest {
+  export function fromJSON(_: any): GetWorldTimeRequest {
     return {};
-  },
+  }
 
-  toJSON(_: GetWorldTimeRequest): unknown {
+  export function toJSON(_: GetWorldTimeRequest): unknown {
     const obj: any = {};
     return obj;
-  },
+  }
 
-  create<I extends Exact<DeepPartial<GetWorldTimeRequest>, I>>(base?: I): GetWorldTimeRequest {
+  export function create<I extends Exact<DeepPartial<GetWorldTimeRequest>, I>>(base?: I): GetWorldTimeRequest {
     return GetWorldTimeRequest.fromPartial(base ?? {});
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<GetWorldTimeRequest>, I>>(_: I): GetWorldTimeRequest {
+  export function fromPartial<I extends Exact<DeepPartial<GetWorldTimeRequest>, I>>(_: I): GetWorldTimeRequest {
     const message = createBaseGetWorldTimeRequest();
     return message;
-  },
-};
+  }
+}
+
+function createBaseReadFileRequest(): ReadFileRequest {
+  return { fileName: "" };
+}
+
+export namespace ReadFileRequest {
+  export function encode(message: ReadFileRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.fileName !== "") {
+      writer.uint32(10).string(message.fileName);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ReadFileRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReadFileRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.fileName = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ReadFileRequest {
+    return { fileName: isSet(object.fileName) ? String(object.fileName) : "" };
+  }
+
+  export function toJSON(message: ReadFileRequest): unknown {
+    const obj: any = {};
+    message.fileName !== undefined && (obj.fileName = message.fileName);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ReadFileRequest>, I>>(base?: I): ReadFileRequest {
+    return ReadFileRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ReadFileRequest>, I>>(object: I): ReadFileRequest {
+    const message = createBaseReadFileRequest();
+    message.fileName = object.fileName ?? "";
+    return message;
+  }
+}
+
+function createBaseReadFileResponse(): ReadFileResponse {
+  return { content: new Uint8Array(0), hash: "" };
+}
+
+export namespace ReadFileResponse {
+  export function encode(message: ReadFileResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.content.length !== 0) {
+      writer.uint32(10).bytes(message.content);
+    }
+    if (message.hash !== "") {
+      writer.uint32(18).string(message.hash);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): ReadFileResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseReadFileResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.content = reader.bytes();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.hash = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): ReadFileResponse {
+    return {
+      content: isSet(object.content) ? bytesFromBase64(object.content) : new Uint8Array(0),
+      hash: isSet(object.hash) ? String(object.hash) : "",
+    };
+  }
+
+  export function toJSON(message: ReadFileResponse): unknown {
+    const obj: any = {};
+    message.content !== undefined &&
+      (obj.content = base64FromBytes(message.content !== undefined ? message.content : new Uint8Array(0)));
+    message.hash !== undefined && (obj.hash = message.hash);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<ReadFileResponse>, I>>(base?: I): ReadFileResponse {
+    return ReadFileResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<ReadFileResponse>, I>>(object: I): ReadFileResponse {
+    const message = createBaseReadFileResponse();
+    message.content = object.content ?? new Uint8Array(0);
+    message.hash = object.hash ?? "";
+    return message;
+  }
+}
+
+function createBaseCurrentSceneEntityRequest(): CurrentSceneEntityRequest {
+  return {};
+}
+
+export namespace CurrentSceneEntityRequest {
+  export function encode(_: CurrentSceneEntityRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CurrentSceneEntityRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCurrentSceneEntityRequest();
+    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): CurrentSceneEntityRequest {
+    return {};
+  }
+
+  export function toJSON(_: CurrentSceneEntityRequest): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CurrentSceneEntityRequest>, I>>(
+    base?: I,
+  ): CurrentSceneEntityRequest {
+    return CurrentSceneEntityRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CurrentSceneEntityRequest>, I>>(
+    _: I,
+  ): CurrentSceneEntityRequest {
+    const message = createBaseCurrentSceneEntityRequest();
+    return message;
+  }
+}
+
+function createBaseCurrentSceneEntityResponse(): CurrentSceneEntityResponse {
+  return { urn: "", content: [], metadataJson: "", baseUrl: "" };
+}
+
+export namespace CurrentSceneEntityResponse {
+  export function encode(message: CurrentSceneEntityResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.urn !== "") {
+      writer.uint32(10).string(message.urn);
+    }
+    for (const v of message.content) {
+      ContentMapping.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.metadataJson !== "") {
+      writer.uint32(26).string(message.metadataJson);
+    }
+    if (message.baseUrl !== "") {
+      writer.uint32(34).string(message.baseUrl);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): CurrentSceneEntityResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCurrentSceneEntityResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.urn = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.content.push(ContentMapping.decode(reader, reader.uint32()));
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.metadataJson = reader.string();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.baseUrl = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): CurrentSceneEntityResponse {
+    return {
+      urn: isSet(object.urn) ? String(object.urn) : "",
+      content: Array.isArray(object?.content) ? object.content.map((e: any) => ContentMapping.fromJSON(e)) : [],
+      metadataJson: isSet(object.metadataJson) ? String(object.metadataJson) : "",
+      baseUrl: isSet(object.baseUrl) ? String(object.baseUrl) : "",
+    };
+  }
+
+  export function toJSON(message: CurrentSceneEntityResponse): unknown {
+    const obj: any = {};
+    message.urn !== undefined && (obj.urn = message.urn);
+    if (message.content) {
+      obj.content = message.content.map((e) => e ? ContentMapping.toJSON(e) : undefined);
+    } else {
+      obj.content = [];
+    }
+    message.metadataJson !== undefined && (obj.metadataJson = message.metadataJson);
+    message.baseUrl !== undefined && (obj.baseUrl = message.baseUrl);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<CurrentSceneEntityResponse>, I>>(
+    base?: I,
+  ): CurrentSceneEntityResponse {
+    return CurrentSceneEntityResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<CurrentSceneEntityResponse>, I>>(
+    object: I,
+  ): CurrentSceneEntityResponse {
+    const message = createBaseCurrentSceneEntityResponse();
+    message.urn = object.urn ?? "";
+    message.content = object.content?.map((e) => ContentMapping.fromPartial(e)) || [];
+    message.metadataJson = object.metadataJson ?? "";
+    message.baseUrl = object.baseUrl ?? "";
+    return message;
+  }
+}
+
+function createBaseGetExplorerInformationRequest(): GetExplorerInformationRequest {
+  return {};
+}
+
+export namespace GetExplorerInformationRequest {
+  export function encode(_: GetExplorerInformationRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetExplorerInformationRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetExplorerInformationRequest();
+    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): GetExplorerInformationRequest {
+    return {};
+  }
+
+  export function toJSON(_: GetExplorerInformationRequest): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<GetExplorerInformationRequest>, I>>(
+    base?: I,
+  ): GetExplorerInformationRequest {
+    return GetExplorerInformationRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<GetExplorerInformationRequest>, I>>(
+    _: I,
+  ): GetExplorerInformationRequest {
+    const message = createBaseGetExplorerInformationRequest();
+    return message;
+  }
+}
+
+function createBaseGetExplorerInformationResponse(): GetExplorerInformationResponse {
+  return { agent: "", platform: "", configurations: {} };
+}
+
+export namespace GetExplorerInformationResponse {
+  export function encode(
+    message: GetExplorerInformationResponse,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.agent !== "") {
+      writer.uint32(10).string(message.agent);
+    }
+    if (message.platform !== "") {
+      writer.uint32(18).string(message.platform);
+    }
+    Object.entries(message.configurations).forEach(([key, value]) => {
+      GetExplorerInformationResponse_ConfigurationsEntry.encode({ key: key as any, value }, writer.uint32(26).fork())
+        .ldelim();
+    });
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): GetExplorerInformationResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetExplorerInformationResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.agent = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.platform = reader.string();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          const entry3 = GetExplorerInformationResponse_ConfigurationsEntry.decode(reader, reader.uint32());
+          if (entry3.value !== undefined) {
+            message.configurations[entry3.key] = entry3.value;
+          }
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): GetExplorerInformationResponse {
+    return {
+      agent: isSet(object.agent) ? String(object.agent) : "",
+      platform: isSet(object.platform) ? String(object.platform) : "",
+      configurations: isObject(object.configurations)
+        ? Object.entries(object.configurations).reduce<{ [key: string]: string }>((acc, [key, value]) => {
+          acc[key] = String(value);
+          return acc;
+        }, {})
+        : {},
+    };
+  }
+
+  export function toJSON(message: GetExplorerInformationResponse): unknown {
+    const obj: any = {};
+    message.agent !== undefined && (obj.agent = message.agent);
+    message.platform !== undefined && (obj.platform = message.platform);
+    obj.configurations = {};
+    if (message.configurations) {
+      Object.entries(message.configurations).forEach(([k, v]) => {
+        obj.configurations[k] = v;
+      });
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<GetExplorerInformationResponse>, I>>(
+    base?: I,
+  ): GetExplorerInformationResponse {
+    return GetExplorerInformationResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<GetExplorerInformationResponse>, I>>(
+    object: I,
+  ): GetExplorerInformationResponse {
+    const message = createBaseGetExplorerInformationResponse();
+    message.agent = object.agent ?? "";
+    message.platform = object.platform ?? "";
+    message.configurations = Object.entries(object.configurations ?? {}).reduce<{ [key: string]: string }>(
+      (acc, [key, value]) => {
+        if (value !== undefined) {
+          acc[key] = String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  }
+}
+
+function createBaseGetExplorerInformationResponse_ConfigurationsEntry(): GetExplorerInformationResponse_ConfigurationsEntry {
+  return { key: "", value: "" };
+}
+
+export namespace GetExplorerInformationResponse_ConfigurationsEntry {
+  export function encode(
+    message: GetExplorerInformationResponse_ConfigurationsEntry,
+    writer: _m0.Writer = _m0.Writer.create(),
+  ): _m0.Writer {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  }
+
+  export function decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number,
+  ): GetExplorerInformationResponse_ConfigurationsEntry {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetExplorerInformationResponse_ConfigurationsEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): GetExplorerInformationResponse_ConfigurationsEntry {
+    return { key: isSet(object.key) ? String(object.key) : "", value: isSet(object.value) ? String(object.value) : "" };
+  }
+
+  export function toJSON(message: GetExplorerInformationResponse_ConfigurationsEntry): unknown {
+    const obj: any = {};
+    message.key !== undefined && (obj.key = message.key);
+    message.value !== undefined && (obj.value = message.value);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<GetExplorerInformationResponse_ConfigurationsEntry>, I>>(
+    base?: I,
+  ): GetExplorerInformationResponse_ConfigurationsEntry {
+    return GetExplorerInformationResponse_ConfigurationsEntry.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<GetExplorerInformationResponse_ConfigurationsEntry>, I>>(
+    object: I,
+  ): GetExplorerInformationResponse_ConfigurationsEntry {
+    const message = createBaseGetExplorerInformationResponse_ConfigurationsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  }
+}
 
 export type RuntimeServiceDefinition = typeof RuntimeServiceDefinition;
 export const RuntimeServiceDefinition = {
   name: "RuntimeService",
   fullName: "decentraland.kernel.apis.RuntimeService",
   methods: {
+    /** Provides information about the current realm */
     getRealm: {
       name: "GetRealm",
       requestType: GetRealmRequest,
@@ -308,6 +799,10 @@ export const RuntimeServiceDefinition = {
       responseStream: false,
       options: {},
     },
+    /**
+     * Provides information about the Decentraland Time, which is coordinated
+     * across players.
+     */
     getWorldTime: {
       name: "GetWorldTime",
       requestType: GetWorldTimeRequest,
@@ -316,9 +811,85 @@ export const RuntimeServiceDefinition = {
       responseStream: false,
       options: {},
     },
+    /**
+     * Returns the file content of a deployed asset. If the file doesn't
+     * exist or cannot be retrieved, the RPC call throws an error.
+     * This method is called to load any assets deployed among the scene,
+     * runtime may cache this response much more than the provided "fetch" function.
+     */
+    readFile: {
+      name: "ReadFile",
+      requestType: ReadFileRequest,
+      requestStream: false,
+      responseType: ReadFileResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Returns information about the current scene. This is the replacement of GetBootstrapData */
+    getSceneInformation: {
+      name: "GetSceneInformation",
+      requestType: CurrentSceneEntityRequest,
+      requestStream: false,
+      responseType: CurrentSceneEntityResponse,
+      responseStream: false,
+      options: {},
+    },
+    /** Provides information about the explorer */
+    getExplorerInformation: {
+      name: "GetExplorerInformation",
+      requestType: GetExplorerInformationRequest,
+      requestStream: false,
+      responseType: GetExplorerInformationResponse,
+      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
@@ -331,6 +902,10 @@ 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 isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
 function isSet(value: any): boolean {
   return value !== null && value !== undefined;
 }