@dcl/protocol 1.0.0-3227242807.commit-ad14cba → 1.0.0-32360428523.commit-60c2fb5

package/out-ts/{kernel/apis/Permissions.gen.ts → decentraland/kernel/apis/permissions.gen.ts}

@@ -1,34 +1,42 @@
 /* eslint-disable */
 import _m0 from "protobufjs/minimal";
 
-export const protobufPackage = "";
+export const protobufPackage = "decentraland.kernel.apis";
 
 export enum PermissionItem {
-  ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE = 0,
-  ALLOW_TO_TRIGGER_AVATAR_EMOTE = 1,
-  USE_WEB3_API = 2,
-  USE_WEBSOCKET = 3,
-  USE_FETCH = 4,
+  PI_ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE = 0,
+  PI_ALLOW_TO_TRIGGER_AVATAR_EMOTE = 1,
+  PI_USE_WEB3_API = 2,
+  PI_USE_WEBSOCKET = 3,
+  PI_USE_FETCH = 4,
+  PI_ALLOW_MEDIA_HOSTNAMES = 5,
+  PI_OPEN_EXTERNAL_LINK = 6,
   UNRECOGNIZED = -1,
 }
 
 export function permissionItemFromJSON(object: any): PermissionItem {
   switch (object) {
     case 0:
-    case "ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE":
-      return PermissionItem.ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE;
+    case "PI_ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE":
+      return PermissionItem.PI_ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE;
     case 1:
-    case "ALLOW_TO_TRIGGER_AVATAR_EMOTE":
-      return PermissionItem.ALLOW_TO_TRIGGER_AVATAR_EMOTE;
+    case "PI_ALLOW_TO_TRIGGER_AVATAR_EMOTE":
+      return PermissionItem.PI_ALLOW_TO_TRIGGER_AVATAR_EMOTE;
     case 2:
-    case "USE_WEB3_API":
-      return PermissionItem.USE_WEB3_API;
+    case "PI_USE_WEB3_API":
+      return PermissionItem.PI_USE_WEB3_API;
     case 3:
-    case "USE_WEBSOCKET":
-      return PermissionItem.USE_WEBSOCKET;
+    case "PI_USE_WEBSOCKET":
+      return PermissionItem.PI_USE_WEBSOCKET;
     case 4:
-    case "USE_FETCH":
-      return PermissionItem.USE_FETCH;
+    case "PI_USE_FETCH":
+      return PermissionItem.PI_USE_FETCH;
+    case 5:
+    case "PI_ALLOW_MEDIA_HOSTNAMES":
+      return PermissionItem.PI_ALLOW_MEDIA_HOSTNAMES;
+    case 6:
+    case "PI_OPEN_EXTERNAL_LINK":
+      return PermissionItem.PI_OPEN_EXTERNAL_LINK;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -38,16 +46,20 @@ export function permissionItemFromJSON(object: any): PermissionItem {
 
 export function permissionItemToJSON(object: PermissionItem): string {
   switch (object) {
-    case PermissionItem.ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE:
-      return "ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE";
-    case PermissionItem.ALLOW_TO_TRIGGER_AVATAR_EMOTE:
-      return "ALLOW_TO_TRIGGER_AVATAR_EMOTE";
-    case PermissionItem.USE_WEB3_API:
-      return "USE_WEB3_API";
-    case PermissionItem.USE_WEBSOCKET:
-      return "USE_WEBSOCKET";
-    case PermissionItem.USE_FETCH:
-      return "USE_FETCH";
+    case PermissionItem.PI_ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE:
+      return "PI_ALLOW_TO_MOVE_PLAYER_INSIDE_SCENE";
+    case PermissionItem.PI_ALLOW_TO_TRIGGER_AVATAR_EMOTE:
+      return "PI_ALLOW_TO_TRIGGER_AVATAR_EMOTE";
+    case PermissionItem.PI_USE_WEB3_API:
+      return "PI_USE_WEB3_API";
+    case PermissionItem.PI_USE_WEBSOCKET:
+      return "PI_USE_WEBSOCKET";
+    case PermissionItem.PI_USE_FETCH:
+      return "PI_USE_FETCH";
+    case PermissionItem.PI_ALLOW_MEDIA_HOSTNAMES:
+      return "PI_ALLOW_MEDIA_HOSTNAMES";
+    case PermissionItem.PI_OPEN_EXTERNAL_LINK:
+      return "PI_OPEN_EXTERNAL_LINK";
     case PermissionItem.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
@@ -74,144 +86,170 @@ function createBasePermissionResponse(): PermissionResponse {
   return { hasPermission: false };
 }
 
-export const PermissionResponse = {
-  encode(message: PermissionResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace PermissionResponse {
+  export function encode(message: PermissionResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.hasPermission === true) {
       writer.uint32(8).bool(message.hasPermission);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): PermissionResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PermissionResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBasePermissionResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 8) {
+            break;
+          }
+
           message.hasPermission = reader.bool();
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): PermissionResponse {
+  export function fromJSON(object: any): PermissionResponse {
     return { hasPermission: isSet(object.hasPermission) ? Boolean(object.hasPermission) : false };
-  },
+  }
 
-  toJSON(message: PermissionResponse): unknown {
+  export function toJSON(message: PermissionResponse): unknown {
     const obj: any = {};
     message.hasPermission !== undefined && (obj.hasPermission = message.hasPermission);
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<PermissionResponse>, I>>(base?: I): PermissionResponse {
+    return PermissionResponse.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<PermissionResponse>, I>>(object: I): PermissionResponse {
+  export function fromPartial<I extends Exact<DeepPartial<PermissionResponse>, I>>(object: I): PermissionResponse {
     const message = createBasePermissionResponse();
     message.hasPermission = object.hasPermission ?? false;
     return message;
-  },
-};
+  }
+}
 
 function createBaseHasPermissionRequest(): HasPermissionRequest {
   return { permission: 0 };
 }
 
-export const HasPermissionRequest = {
-  encode(message: HasPermissionRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace HasPermissionRequest {
+  export function encode(message: HasPermissionRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     if (message.permission !== 0) {
       writer.uint32(8).int32(message.permission);
     }
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): HasPermissionRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): HasPermissionRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseHasPermissionRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
+          if (tag !== 8) {
+            break;
+          }
+
           message.permission = reader.int32() as any;
-          break;
-        default:
-          reader.skipType(tag & 7);
-          break;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
       }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): HasPermissionRequest {
+  export function fromJSON(object: any): HasPermissionRequest {
     return { permission: isSet(object.permission) ? permissionItemFromJSON(object.permission) : 0 };
-  },
+  }
 
-  toJSON(message: HasPermissionRequest): unknown {
+  export function toJSON(message: HasPermissionRequest): unknown {
     const obj: any = {};
     message.permission !== undefined && (obj.permission = permissionItemToJSON(message.permission));
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<HasPermissionRequest>, I>>(base?: I): HasPermissionRequest {
+    return HasPermissionRequest.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<HasPermissionRequest>, I>>(object: I): HasPermissionRequest {
+  export function fromPartial<I extends Exact<DeepPartial<HasPermissionRequest>, I>>(object: I): HasPermissionRequest {
     const message = createBaseHasPermissionRequest();
     message.permission = object.permission ?? 0;
     return message;
-  },
-};
+  }
+}
 
 function createBaseHasManyPermissionRequest(): HasManyPermissionRequest {
   return { permissions: [] };
 }
 
-export const HasManyPermissionRequest = {
-  encode(message: HasManyPermissionRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace HasManyPermissionRequest {
+  export function encode(message: HasManyPermissionRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     writer.uint32(10).fork();
     for (const v of message.permissions) {
       writer.int32(v);
     }
     writer.ldelim();
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): HasManyPermissionRequest {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): HasManyPermissionRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseHasManyPermissionRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          if ((tag & 7) === 2) {
+          if (tag === 8) {
+            message.permissions.push(reader.int32() as any);
+
+            continue;
+          }
+
+          if (tag === 10) {
             const end2 = reader.uint32() + reader.pos;
             while (reader.pos < end2) {
               message.permissions.push(reader.int32() as any);
             }
-          } else {
-            message.permissions.push(reader.int32() as any);
+
+            continue;
           }
+
           break;
-        default:
-          reader.skipType(tag & 7);
-          break;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): HasManyPermissionRequest {
+  export function fromJSON(object: any): HasManyPermissionRequest {
     return {
       permissions: Array.isArray(object?.permissions)
         ? object.permissions.map((e: any) => permissionItemFromJSON(e))
         : [],
     };
-  },
+  }
 
-  toJSON(message: HasManyPermissionRequest): unknown {
+  export function toJSON(message: HasManyPermissionRequest): unknown {
     const obj: any = {};
     if (message.permissions) {
       obj.permissions = message.permissions.map((e) => permissionItemToJSON(e));
@@ -219,63 +257,79 @@ export const HasManyPermissionRequest = {
       obj.permissions = [];
     }
     return obj;
-  },
+  }
+
+  export function create<I extends Exact<DeepPartial<HasManyPermissionRequest>, I>>(
+    base?: I,
+  ): HasManyPermissionRequest {
+    return HasManyPermissionRequest.fromPartial(base ?? {});
+  }
 
-  fromPartial<I extends Exact<DeepPartial<HasManyPermissionRequest>, I>>(object: I): HasManyPermissionRequest {
+  export function fromPartial<I extends Exact<DeepPartial<HasManyPermissionRequest>, I>>(
+    object: I,
+  ): HasManyPermissionRequest {
     const message = createBaseHasManyPermissionRequest();
     message.permissions = object.permissions?.map((e) => e) || [];
     return message;
-  },
-};
+  }
+}
 
 function createBaseHasManyPermissionResponse(): HasManyPermissionResponse {
   return { hasManyPermission: [] };
 }
 
-export const HasManyPermissionResponse = {
-  encode(message: HasManyPermissionResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export namespace HasManyPermissionResponse {
+  export function encode(message: HasManyPermissionResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
     writer.uint32(10).fork();
     for (const v of message.hasManyPermission) {
       writer.bool(v);
     }
     writer.ldelim();
     return writer;
-  },
+  }
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): HasManyPermissionResponse {
-    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): HasManyPermissionResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseHasManyPermissionResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1:
-          if ((tag & 7) === 2) {
+          if (tag === 8) {
+            message.hasManyPermission.push(reader.bool());
+
+            continue;
+          }
+
+          if (tag === 10) {
             const end2 = reader.uint32() + reader.pos;
             while (reader.pos < end2) {
               message.hasManyPermission.push(reader.bool());
             }
-          } else {
-            message.hasManyPermission.push(reader.bool());
+
+            continue;
           }
-          break;
-        default:
-          reader.skipType(tag & 7);
+
           break;
       }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
     }
     return message;
-  },
+  }
 
-  fromJSON(object: any): HasManyPermissionResponse {
+  export function fromJSON(object: any): HasManyPermissionResponse {
     return {
       hasManyPermission: Array.isArray(object?.hasManyPermission)
         ? object.hasManyPermission.map((e: any) => Boolean(e))
         : [],
     };
-  },
+  }
 
-  toJSON(message: HasManyPermissionResponse): unknown {
+  export function toJSON(message: HasManyPermissionResponse): unknown {
     const obj: any = {};
     if (message.hasManyPermission) {
       obj.hasManyPermission = message.hasManyPermission.map((e) => e);
@@ -283,20 +337,29 @@ export const HasManyPermissionResponse = {
       obj.hasManyPermission = [];
     }
     return obj;
-  },
+  }
 
-  fromPartial<I extends Exact<DeepPartial<HasManyPermissionResponse>, I>>(object: I): HasManyPermissionResponse {
+  export function create<I extends Exact<DeepPartial<HasManyPermissionResponse>, I>>(
+    base?: I,
+  ): HasManyPermissionResponse {
+    return HasManyPermissionResponse.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<HasManyPermissionResponse>, I>>(
+    object: I,
+  ): HasManyPermissionResponse {
     const message = createBaseHasManyPermissionResponse();
     message.hasManyPermission = object.hasManyPermission?.map((e) => e) || [];
     return message;
-  },
-};
+  }
+}
 
 export type PermissionsServiceDefinition = typeof PermissionsServiceDefinition;
 export const PermissionsServiceDefinition = {
   name: "PermissionsService",
-  fullName: "PermissionsService",
+  fullName: "decentraland.kernel.apis.PermissionsService",
   methods: {
+    /** @deprecated, only available for SDK6 compatibility */
     hasPermission: {
       name: "HasPermission",
       requestType: HasPermissionRequest,
@@ -305,6 +368,7 @@ export const PermissionsServiceDefinition = {
       responseStream: false,
       options: {},
     },
+    /** @deprecated, only available for SDK6 compatibility */
     hasManyPermissions: {
       name: "HasManyPermissions",
       requestType: HasManyPermissionRequest,
@@ -320,6 +384,7 @@ type Builtin = Date | Function | Uint8Array | string | number | boolean | undefi
 
 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>;