@dcl/protocol 1.0.0-4427886959.commit-6b9dcb5 → 1.0.0-4468031496.commit-eace17b

package/out-ts/decentraland/sdk/components/nft_shape.gen.ts

@@ -0,0 +1,288 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { Color3 } from "../../common/colors.gen";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/** NftFrameType is a predefined framing style for the image. */
+export enum NftFrameType {
+  NFT_CLASSIC = 0,
+  NFT_BAROQUE_ORNAMENT = 1,
+  NFT_DIAMOND_ORNAMENT = 2,
+  NFT_MINIMAL_WIDE = 3,
+  NFT_MINIMAL_GREY = 4,
+  NFT_BLOCKY = 5,
+  NFT_GOLD_EDGES = 6,
+  NFT_GOLD_CARVED = 7,
+  NFT_GOLD_WIDE = 8,
+  NFT_GOLD_ROUNDED = 9,
+  NFT_METAL_MEDIUM = 10,
+  NFT_METAL_WIDE = 11,
+  NFT_METAL_SLIM = 12,
+  NFT_METAL_ROUNDED = 13,
+  NFT_PINS = 14,
+  NFT_MINIMAL_BLACK = 15,
+  NFT_MINIMAL_WHITE = 16,
+  NFT_TAPE = 17,
+  NFT_WOOD_SLIM = 18,
+  NFT_WOOD_WIDE = 19,
+  NFT_WOOD_TWIGS = 20,
+  NFT_CANVAS = 21,
+  NFT_NONE = 22,
+  UNRECOGNIZED = -1,
+}
+
+export function nftFrameTypeFromJSON(object: any): NftFrameType {
+  switch (object) {
+    case 0:
+    case "NFT_CLASSIC":
+      return NftFrameType.NFT_CLASSIC;
+    case 1:
+    case "NFT_BAROQUE_ORNAMENT":
+      return NftFrameType.NFT_BAROQUE_ORNAMENT;
+    case 2:
+    case "NFT_DIAMOND_ORNAMENT":
+      return NftFrameType.NFT_DIAMOND_ORNAMENT;
+    case 3:
+    case "NFT_MINIMAL_WIDE":
+      return NftFrameType.NFT_MINIMAL_WIDE;
+    case 4:
+    case "NFT_MINIMAL_GREY":
+      return NftFrameType.NFT_MINIMAL_GREY;
+    case 5:
+    case "NFT_BLOCKY":
+      return NftFrameType.NFT_BLOCKY;
+    case 6:
+    case "NFT_GOLD_EDGES":
+      return NftFrameType.NFT_GOLD_EDGES;
+    case 7:
+    case "NFT_GOLD_CARVED":
+      return NftFrameType.NFT_GOLD_CARVED;
+    case 8:
+    case "NFT_GOLD_WIDE":
+      return NftFrameType.NFT_GOLD_WIDE;
+    case 9:
+    case "NFT_GOLD_ROUNDED":
+      return NftFrameType.NFT_GOLD_ROUNDED;
+    case 10:
+    case "NFT_METAL_MEDIUM":
+      return NftFrameType.NFT_METAL_MEDIUM;
+    case 11:
+    case "NFT_METAL_WIDE":
+      return NftFrameType.NFT_METAL_WIDE;
+    case 12:
+    case "NFT_METAL_SLIM":
+      return NftFrameType.NFT_METAL_SLIM;
+    case 13:
+    case "NFT_METAL_ROUNDED":
+      return NftFrameType.NFT_METAL_ROUNDED;
+    case 14:
+    case "NFT_PINS":
+      return NftFrameType.NFT_PINS;
+    case 15:
+    case "NFT_MINIMAL_BLACK":
+      return NftFrameType.NFT_MINIMAL_BLACK;
+    case 16:
+    case "NFT_MINIMAL_WHITE":
+      return NftFrameType.NFT_MINIMAL_WHITE;
+    case 17:
+    case "NFT_TAPE":
+      return NftFrameType.NFT_TAPE;
+    case 18:
+    case "NFT_WOOD_SLIM":
+      return NftFrameType.NFT_WOOD_SLIM;
+    case 19:
+    case "NFT_WOOD_WIDE":
+      return NftFrameType.NFT_WOOD_WIDE;
+    case 20:
+    case "NFT_WOOD_TWIGS":
+      return NftFrameType.NFT_WOOD_TWIGS;
+    case 21:
+    case "NFT_CANVAS":
+      return NftFrameType.NFT_CANVAS;
+    case 22:
+    case "NFT_NONE":
+      return NftFrameType.NFT_NONE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return NftFrameType.UNRECOGNIZED;
+  }
+}
+
+export function nftFrameTypeToJSON(object: NftFrameType): string {
+  switch (object) {
+    case NftFrameType.NFT_CLASSIC:
+      return "NFT_CLASSIC";
+    case NftFrameType.NFT_BAROQUE_ORNAMENT:
+      return "NFT_BAROQUE_ORNAMENT";
+    case NftFrameType.NFT_DIAMOND_ORNAMENT:
+      return "NFT_DIAMOND_ORNAMENT";
+    case NftFrameType.NFT_MINIMAL_WIDE:
+      return "NFT_MINIMAL_WIDE";
+    case NftFrameType.NFT_MINIMAL_GREY:
+      return "NFT_MINIMAL_GREY";
+    case NftFrameType.NFT_BLOCKY:
+      return "NFT_BLOCKY";
+    case NftFrameType.NFT_GOLD_EDGES:
+      return "NFT_GOLD_EDGES";
+    case NftFrameType.NFT_GOLD_CARVED:
+      return "NFT_GOLD_CARVED";
+    case NftFrameType.NFT_GOLD_WIDE:
+      return "NFT_GOLD_WIDE";
+    case NftFrameType.NFT_GOLD_ROUNDED:
+      return "NFT_GOLD_ROUNDED";
+    case NftFrameType.NFT_METAL_MEDIUM:
+      return "NFT_METAL_MEDIUM";
+    case NftFrameType.NFT_METAL_WIDE:
+      return "NFT_METAL_WIDE";
+    case NftFrameType.NFT_METAL_SLIM:
+      return "NFT_METAL_SLIM";
+    case NftFrameType.NFT_METAL_ROUNDED:
+      return "NFT_METAL_ROUNDED";
+    case NftFrameType.NFT_PINS:
+      return "NFT_PINS";
+    case NftFrameType.NFT_MINIMAL_BLACK:
+      return "NFT_MINIMAL_BLACK";
+    case NftFrameType.NFT_MINIMAL_WHITE:
+      return "NFT_MINIMAL_WHITE";
+    case NftFrameType.NFT_TAPE:
+      return "NFT_TAPE";
+    case NftFrameType.NFT_WOOD_SLIM:
+      return "NFT_WOOD_SLIM";
+    case NftFrameType.NFT_WOOD_WIDE:
+      return "NFT_WOOD_WIDE";
+    case NftFrameType.NFT_WOOD_TWIGS:
+      return "NFT_WOOD_TWIGS";
+    case NftFrameType.NFT_CANVAS:
+      return "NFT_CANVAS";
+    case NftFrameType.NFT_NONE:
+      return "NFT_NONE";
+    case NftFrameType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/**
+ * The NftShape component renders a framed picture from an NFT. It supports PNG, JPEG and GIF files.
+ *
+ * The `src` field is the URI of the NFT, which includes its parent contract and index, using
+ * the `https:` or `ethereum:` schemes.
+ *
+ * The picture frame can have several different styles, plus a background color for images that have
+ * transparent pixels.
+ */
+export interface PBNftShape {
+  /** the URI of the NFT */
+  src: string;
+  /** the frame style (default NFT_CLASSIC) */
+  style?:
+    | NftFrameType
+    | undefined;
+  /** RGB background (default [0.6404918, 0.611472, 0.8584906]) */
+  color?: Color3 | undefined;
+}
+
+function createBasePBNftShape(): PBNftShape {
+  return { src: "", style: undefined, color: undefined };
+}
+
+export const PBNftShape = {
+  encode(message: PBNftShape, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.src !== "") {
+      writer.uint32(10).string(message.src);
+    }
+    if (message.style !== undefined) {
+      writer.uint32(16).int32(message.style);
+    }
+    if (message.color !== undefined) {
+      Color3.encode(message.color, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PBNftShape {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBNftShape();
+    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.style = reader.int32() as any;
+          continue;
+        case 3:
+          if (tag != 26) {
+            break;
+          }
+
+          message.color = Color3.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PBNftShape {
+    return {
+      src: isSet(object.src) ? String(object.src) : "",
+      style: isSet(object.style) ? nftFrameTypeFromJSON(object.style) : undefined,
+      color: isSet(object.color) ? Color3.fromJSON(object.color) : undefined,
+    };
+  },
+
+  toJSON(message: PBNftShape): unknown {
+    const obj: any = {};
+    message.src !== undefined && (obj.src = message.src);
+    message.style !== undefined &&
+      (obj.style = message.style !== undefined ? nftFrameTypeToJSON(message.style) : undefined);
+    message.color !== undefined && (obj.color = message.color ? Color3.toJSON(message.color) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PBNftShape>, I>>(base?: I): PBNftShape {
+    return PBNftShape.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PBNftShape>, I>>(object: I): PBNftShape {
+    const message = createBasePBNftShape();
+    message.src = object.src ?? "";
+    message.style = object.style ?? undefined;
+    message.color = (object.color !== undefined && object.color !== null)
+      ? Color3.fromPartial(object.color)
+      : undefined;
+    return message;
+  },
+};
+
+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/sdk/components/pointer_events.gen.ts

@@ -0,0 +1,347 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { InputAction, inputActionFromJSON, inputActionToJSON } from "./common/input_action.gen";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+/** PointerEventType is a kind of interaction that can be detected. */
+export enum PointerEventType {
+  PET_UP = 0,
+  PET_DOWN = 1,
+  PET_HOVER_ENTER = 2,
+  PET_HOVER_LEAVE = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function pointerEventTypeFromJSON(object: any): PointerEventType {
+  switch (object) {
+    case 0:
+    case "PET_UP":
+      return PointerEventType.PET_UP;
+    case 1:
+    case "PET_DOWN":
+      return PointerEventType.PET_DOWN;
+    case 2:
+    case "PET_HOVER_ENTER":
+      return PointerEventType.PET_HOVER_ENTER;
+    case 3:
+    case "PET_HOVER_LEAVE":
+      return PointerEventType.PET_HOVER_LEAVE;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return PointerEventType.UNRECOGNIZED;
+  }
+}
+
+export function pointerEventTypeToJSON(object: PointerEventType): string {
+  switch (object) {
+    case PointerEventType.PET_UP:
+      return "PET_UP";
+    case PointerEventType.PET_DOWN:
+      return "PET_DOWN";
+    case PointerEventType.PET_HOVER_ENTER:
+      return "PET_HOVER_ENTER";
+    case PointerEventType.PET_HOVER_LEAVE:
+      return "PET_HOVER_LEAVE";
+    case PointerEventType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/**
+ * PointerEvents adds configurable pointer-based interactions to the attached Entity.
+ *
+ * Events that match the criteria defined in the PointerEvents structure are reported back to the
+ * Entity via the PointerEventsResult component.
+ *
+ * Some examples of events that can be detected:
+ * - Pointer hovering over the Entity.
+ * - Held mouse button released over the Entity.
+ * - Controller button pressed while targeting the Entity.
+ * - Key pressed while targeting the Entity, but only in close range.
+ *
+ * It also supports simple visual feedback when interactions occur, by showing floating text.
+ * More sophisticated feedback requires the use of other components.
+ */
+export interface PBPointerEvents {
+  /** the list of relevant events to detect */
+  pointerEvents: PBPointerEvents_Entry[];
+}
+
+export interface PBPointerEvents_Info {
+  /** key/button in use (default IA_ANY) */
+  button?:
+    | InputAction
+    | undefined;
+  /** feedback on hover (default 'Interact') */
+  hoverText?:
+    | string
+    | undefined;
+  /** range of interaction (default 10) */
+  maxDistance?:
+    | number
+    | undefined;
+  /** enable or disable hover text (default true) */
+  showFeedback?: boolean | undefined;
+}
+
+export interface PBPointerEvents_Entry {
+  /** the kind of interaction to detect */
+  eventType: PointerEventType;
+  /** additional configuration for this detection */
+  eventInfo: PBPointerEvents_Info | undefined;
+}
+
+function createBasePBPointerEvents(): PBPointerEvents {
+  return { pointerEvents: [] };
+}
+
+export const PBPointerEvents = {
+  encode(message: PBPointerEvents, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.pointerEvents) {
+      PBPointerEvents_Entry.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEvents {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBPointerEvents();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag != 10) {
+            break;
+          }
+
+          message.pointerEvents.push(PBPointerEvents_Entry.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PBPointerEvents {
+    return {
+      pointerEvents: Array.isArray(object?.pointerEvents)
+        ? object.pointerEvents.map((e: any) => PBPointerEvents_Entry.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: PBPointerEvents): unknown {
+    const obj: any = {};
+    if (message.pointerEvents) {
+      obj.pointerEvents = message.pointerEvents.map((e) => e ? PBPointerEvents_Entry.toJSON(e) : undefined);
+    } else {
+      obj.pointerEvents = [];
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PBPointerEvents>, I>>(base?: I): PBPointerEvents {
+    return PBPointerEvents.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PBPointerEvents>, I>>(object: I): PBPointerEvents {
+    const message = createBasePBPointerEvents();
+    message.pointerEvents = object.pointerEvents?.map((e) => PBPointerEvents_Entry.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBasePBPointerEvents_Info(): PBPointerEvents_Info {
+  return { button: undefined, hoverText: undefined, maxDistance: undefined, showFeedback: undefined };
+}
+
+export const PBPointerEvents_Info = {
+  encode(message: PBPointerEvents_Info, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.button !== undefined) {
+      writer.uint32(8).int32(message.button);
+    }
+    if (message.hoverText !== undefined) {
+      writer.uint32(18).string(message.hoverText);
+    }
+    if (message.maxDistance !== undefined) {
+      writer.uint32(29).float(message.maxDistance);
+    }
+    if (message.showFeedback !== undefined) {
+      writer.uint32(32).bool(message.showFeedback);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEvents_Info {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBPointerEvents_Info();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag != 8) {
+            break;
+          }
+
+          message.button = reader.int32() as any;
+          continue;
+        case 2:
+          if (tag != 18) {
+            break;
+          }
+
+          message.hoverText = reader.string();
+          continue;
+        case 3:
+          if (tag != 29) {
+            break;
+          }
+
+          message.maxDistance = reader.float();
+          continue;
+        case 4:
+          if (tag != 32) {
+            break;
+          }
+
+          message.showFeedback = reader.bool();
+          continue;
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PBPointerEvents_Info {
+    return {
+      button: isSet(object.button) ? inputActionFromJSON(object.button) : undefined,
+      hoverText: isSet(object.hoverText) ? String(object.hoverText) : undefined,
+      maxDistance: isSet(object.maxDistance) ? Number(object.maxDistance) : undefined,
+      showFeedback: isSet(object.showFeedback) ? Boolean(object.showFeedback) : undefined,
+    };
+  },
+
+  toJSON(message: PBPointerEvents_Info): unknown {
+    const obj: any = {};
+    message.button !== undefined &&
+      (obj.button = message.button !== undefined ? inputActionToJSON(message.button) : undefined);
+    message.hoverText !== undefined && (obj.hoverText = message.hoverText);
+    message.maxDistance !== undefined && (obj.maxDistance = message.maxDistance);
+    message.showFeedback !== undefined && (obj.showFeedback = message.showFeedback);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PBPointerEvents_Info>, I>>(base?: I): PBPointerEvents_Info {
+    return PBPointerEvents_Info.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PBPointerEvents_Info>, I>>(object: I): PBPointerEvents_Info {
+    const message = createBasePBPointerEvents_Info();
+    message.button = object.button ?? undefined;
+    message.hoverText = object.hoverText ?? undefined;
+    message.maxDistance = object.maxDistance ?? undefined;
+    message.showFeedback = object.showFeedback ?? undefined;
+    return message;
+  },
+};
+
+function createBasePBPointerEvents_Entry(): PBPointerEvents_Entry {
+  return { eventType: 0, eventInfo: undefined };
+}
+
+export const PBPointerEvents_Entry = {
+  encode(message: PBPointerEvents_Entry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.eventType !== 0) {
+      writer.uint32(8).int32(message.eventType);
+    }
+    if (message.eventInfo !== undefined) {
+      PBPointerEvents_Info.encode(message.eventInfo, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEvents_Entry {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBPointerEvents_Entry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag != 8) {
+            break;
+          }
+
+          message.eventType = reader.int32() as any;
+          continue;
+        case 2:
+          if (tag != 18) {
+            break;
+          }
+
+          message.eventInfo = PBPointerEvents_Info.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) == 4 || tag == 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PBPointerEvents_Entry {
+    return {
+      eventType: isSet(object.eventType) ? pointerEventTypeFromJSON(object.eventType) : 0,
+      eventInfo: isSet(object.eventInfo) ? PBPointerEvents_Info.fromJSON(object.eventInfo) : undefined,
+    };
+  },
+
+  toJSON(message: PBPointerEvents_Entry): unknown {
+    const obj: any = {};
+    message.eventType !== undefined && (obj.eventType = pointerEventTypeToJSON(message.eventType));
+    message.eventInfo !== undefined &&
+      (obj.eventInfo = message.eventInfo ? PBPointerEvents_Info.toJSON(message.eventInfo) : undefined);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PBPointerEvents_Entry>, I>>(base?: I): PBPointerEvents_Entry {
+    return PBPointerEvents_Entry.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<PBPointerEvents_Entry>, I>>(object: I): PBPointerEvents_Entry {
+    const message = createBasePBPointerEvents_Entry();
+    message.eventType = object.eventType ?? 0;
+    message.eventInfo = (object.eventInfo !== undefined && object.eventInfo !== null)
+      ? PBPointerEvents_Info.fromPartial(object.eventInfo)
+      : undefined;
+    return message;
+  },
+};
+
+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;
+}