@dcl/protocol 1.0.0-2689188518.commit-e68d82c → 1.0.0-27167791416.commit-a470b13

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

@@ -0,0 +1,434 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.kernel.apis";
+
+export interface RealSendRequest {
+  message: string;
+}
+
+export interface RealSendResponse {
+}
+
+export interface SendBinaryRequest {
+  /** @deprecated old broadcasted messages. Use peerData with an empty array for broadcasting. */
+  data: Uint8Array[];
+  /** peer-to-peer messages */
+  peerData: PeerMessageData[];
+}
+
+export interface PeerMessageData {
+  data: Uint8Array[];
+  /** if address is empty, its a broadcast message */
+  address: string[];
+}
+
+export interface SendBinaryResponse {
+  data: Uint8Array[];
+}
+
+function createBaseRealSendRequest(): RealSendRequest {
+  return { message: "" };
+}
+
+export namespace RealSendRequest {
+  export function encode(message: RealSendRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.message !== "") {
+      writer.uint32(10).string(message.message);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): RealSendRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRealSendRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): RealSendRequest {
+    return { message: isSet(object.message) ? String(object.message) : "" };
+  }
+
+  export function toJSON(message: RealSendRequest): unknown {
+    const obj: any = {};
+    message.message !== undefined && (obj.message = message.message);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<RealSendRequest>, I>>(base?: I): RealSendRequest {
+    return RealSendRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<RealSendRequest>, I>>(object: I): RealSendRequest {
+    const message = createBaseRealSendRequest();
+    message.message = object.message ?? "";
+    return message;
+  }
+}
+
+function createBaseRealSendResponse(): RealSendResponse {
+  return {};
+}
+
+export namespace RealSendResponse {
+  export function encode(_: RealSendResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): RealSendResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRealSendResponse();
+    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): RealSendResponse {
+    return {};
+  }
+
+  export function toJSON(_: RealSendResponse): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<RealSendResponse>, I>>(base?: I): RealSendResponse {
+    return RealSendResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<RealSendResponse>, I>>(_: I): RealSendResponse {
+    const message = createBaseRealSendResponse();
+    return message;
+  }
+}
+
+function createBaseSendBinaryRequest(): SendBinaryRequest {
+  return { data: [], peerData: [] };
+}
+
+export namespace SendBinaryRequest {
+  export function encode(message: SendBinaryRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.data) {
+      writer.uint32(10).bytes(v!);
+    }
+    for (const v of message.peerData) {
+      PeerMessageData.encode(v!, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SendBinaryRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSendBinaryRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.data.push(reader.bytes());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.peerData.push(PeerMessageData.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): SendBinaryRequest {
+    return {
+      data: Array.isArray(object?.data) ? object.data.map((e: any) => bytesFromBase64(e)) : [],
+      peerData: Array.isArray(object?.peerData) ? object.peerData.map((e: any) => PeerMessageData.fromJSON(e)) : [],
+    };
+  }
+
+  export function toJSON(message: SendBinaryRequest): unknown {
+    const obj: any = {};
+    if (message.data) {
+      obj.data = message.data.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array(0)));
+    } else {
+      obj.data = [];
+    }
+    if (message.peerData) {
+      obj.peerData = message.peerData.map((e) => e ? PeerMessageData.toJSON(e) : undefined);
+    } else {
+      obj.peerData = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SendBinaryRequest>, I>>(base?: I): SendBinaryRequest {
+    return SendBinaryRequest.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SendBinaryRequest>, I>>(object: I): SendBinaryRequest {
+    const message = createBaseSendBinaryRequest();
+    message.data = object.data?.map((e) => e) || [];
+    message.peerData = object.peerData?.map((e) => PeerMessageData.fromPartial(e)) || [];
+    return message;
+  }
+}
+
+function createBasePeerMessageData(): PeerMessageData {
+  return { data: [], address: [] };
+}
+
+export namespace PeerMessageData {
+  export function encode(message: PeerMessageData, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.data) {
+      writer.uint32(10).bytes(v!);
+    }
+    for (const v of message.address) {
+      writer.uint32(18).string(v!);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PeerMessageData {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePeerMessageData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.data.push(reader.bytes());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.address.push(reader.string());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PeerMessageData {
+    return {
+      data: Array.isArray(object?.data) ? object.data.map((e: any) => bytesFromBase64(e)) : [],
+      address: Array.isArray(object?.address) ? object.address.map((e: any) => String(e)) : [],
+    };
+  }
+
+  export function toJSON(message: PeerMessageData): unknown {
+    const obj: any = {};
+    if (message.data) {
+      obj.data = message.data.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array(0)));
+    } else {
+      obj.data = [];
+    }
+    if (message.address) {
+      obj.address = message.address.map((e) => e);
+    } else {
+      obj.address = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PeerMessageData>, I>>(base?: I): PeerMessageData {
+    return PeerMessageData.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PeerMessageData>, I>>(object: I): PeerMessageData {
+    const message = createBasePeerMessageData();
+    message.data = object.data?.map((e) => e) || [];
+    message.address = object.address?.map((e) => e) || [];
+    return message;
+  }
+}
+
+function createBaseSendBinaryResponse(): SendBinaryResponse {
+  return { data: [] };
+}
+
+export namespace SendBinaryResponse {
+  export function encode(message: SendBinaryResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.data) {
+      writer.uint32(10).bytes(v!);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): SendBinaryResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSendBinaryResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.data.push(reader.bytes());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): SendBinaryResponse {
+    return { data: Array.isArray(object?.data) ? object.data.map((e: any) => bytesFromBase64(e)) : [] };
+  }
+
+  export function toJSON(message: SendBinaryResponse): unknown {
+    const obj: any = {};
+    if (message.data) {
+      obj.data = message.data.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array(0)));
+    } else {
+      obj.data = [];
+    }
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<SendBinaryResponse>, I>>(base?: I): SendBinaryResponse {
+    return SendBinaryResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<SendBinaryResponse>, I>>(object: I): SendBinaryResponse {
+    const message = createBaseSendBinaryResponse();
+    message.data = object.data?.map((e) => e) || [];
+    return message;
+  }
+}
+
+export type CommunicationsControllerServiceDefinition = typeof CommunicationsControllerServiceDefinition;
+export const CommunicationsControllerServiceDefinition = {
+  name: "CommunicationsControllerService",
+  fullName: "decentraland.kernel.apis.CommunicationsControllerService",
+  methods: {
+    /**
+     * @deprecated - This API should use a bidirectional binary stream in sdk7
+     * https://github.com/decentraland/sdk/issues/582
+     */
+    send: {
+      name: "Send",
+      requestType: RealSendRequest,
+      requestStream: false,
+      responseType: RealSendResponse,
+      responseStream: false,
+      options: {},
+    },
+    sendBinary: {
+      name: "SendBinary",
+      requestType: SendBinaryRequest,
+      requestStream: false,
+      responseType: SendBinaryResponse,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+declare const self: any | undefined;
+declare const window: any | undefined;
+declare const global: any | undefined;
+const tsProtoGlobalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if (tsProtoGlobalThis.Buffer) {
+    return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = tsProtoGlobalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (tsProtoGlobalThis.Buffer) {
+    return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(String.fromCharCode(byte));
+    });
+    return tsProtoGlobalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

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

@@ -0,0 +1,161 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+
+export const protobufPackage = "decentraland.kernel.apis";
+
+export interface DevToolsBody {
+  type: string;
+  jsonPayload: string;
+}
+
+export interface EventResponse {
+}
+
+function createBaseDevToolsBody(): DevToolsBody {
+  return { type: "", jsonPayload: "" };
+}
+
+export namespace DevToolsBody {
+  export function encode(message: DevToolsBody, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.type !== "") {
+      writer.uint32(10).string(message.type);
+    }
+    if (message.jsonPayload !== "") {
+      writer.uint32(18).string(message.jsonPayload);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): DevToolsBody {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDevToolsBody();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.type = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.jsonPayload = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): DevToolsBody {
+    return {
+      type: isSet(object.type) ? String(object.type) : "",
+      jsonPayload: isSet(object.jsonPayload) ? String(object.jsonPayload) : "",
+    };
+  }
+
+  export function toJSON(message: DevToolsBody): unknown {
+    const obj: any = {};
+    message.type !== undefined && (obj.type = message.type);
+    message.jsonPayload !== undefined && (obj.jsonPayload = message.jsonPayload);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<DevToolsBody>, I>>(base?: I): DevToolsBody {
+    return DevToolsBody.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<DevToolsBody>, I>>(object: I): DevToolsBody {
+    const message = createBaseDevToolsBody();
+    message.type = object.type ?? "";
+    message.jsonPayload = object.jsonPayload ?? "";
+    return message;
+  }
+}
+
+function createBaseEventResponse(): EventResponse {
+  return {};
+}
+
+export namespace EventResponse {
+  export function encode(_: EventResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): EventResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEventResponse();
+    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): EventResponse {
+    return {};
+  }
+
+  export function toJSON(_: EventResponse): unknown {
+    const obj: any = {};
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<EventResponse>, I>>(base?: I): EventResponse {
+    return EventResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<EventResponse>, I>>(_: I): EventResponse {
+    const message = createBaseEventResponse();
+    return message;
+  }
+}
+
+/** @deprecated */
+export type DevToolsServiceDefinition = typeof DevToolsServiceDefinition;
+export const DevToolsServiceDefinition = {
+  name: "DevToolsService",
+  fullName: "decentraland.kernel.apis.DevToolsService",
+  methods: {
+    /** @deprecated */
+    event: {
+      name: "Event",
+      requestType: DevToolsBody,
+      requestStream: false,
+      responseType: EventResponse,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}