@dcl/protocol 1.0.0-2611981047.commit-6f422a3 → 1.0.0-26120507017.commit-56ef588

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

@@ -0,0 +1,1336 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { Quaternion, Vector2, Vector3 } from "../../common/vectors.gen";
+
+export const protobufPackage = "decentraland.sdk.components";
+
+export enum TextureMovementType {
+  /** TMT_OFFSET - default = TextureMovementType.TMT_OFFSET */
+  TMT_OFFSET = 0,
+  TMT_TILING = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function textureMovementTypeFromJSON(object: any): TextureMovementType {
+  switch (object) {
+    case 0:
+    case "TMT_OFFSET":
+      return TextureMovementType.TMT_OFFSET;
+    case 1:
+    case "TMT_TILING":
+      return TextureMovementType.TMT_TILING;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return TextureMovementType.UNRECOGNIZED;
+  }
+}
+
+export function textureMovementTypeToJSON(object: TextureMovementType): string {
+  switch (object) {
+    case TextureMovementType.TMT_OFFSET:
+      return "TMT_OFFSET";
+    case TextureMovementType.TMT_TILING:
+      return "TMT_TILING";
+    case TextureMovementType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/**
+ * Implementation guidelines for these easing functions can be found
+ * at https://github.com/ai/easings.net/blob/6fcd5f852a470bf1a7890e8178afa0f471d5f2ec/src/easings/easingsFunctions.ts
+ */
+export enum EasingFunction {
+  /** EF_LINEAR - default */
+  EF_LINEAR = 0,
+  EF_EASEINQUAD = 1,
+  EF_EASEOUTQUAD = 2,
+  EF_EASEQUAD = 3,
+  EF_EASEINSINE = 4,
+  EF_EASEOUTSINE = 5,
+  EF_EASESINE = 6,
+  EF_EASEINEXPO = 7,
+  EF_EASEOUTEXPO = 8,
+  EF_EASEEXPO = 9,
+  EF_EASEINELASTIC = 10,
+  EF_EASEOUTELASTIC = 11,
+  EF_EASEELASTIC = 12,
+  EF_EASEINBOUNCE = 13,
+  EF_EASEOUTBOUNCE = 14,
+  EF_EASEBOUNCE = 15,
+  EF_EASEINCUBIC = 16,
+  EF_EASEOUTCUBIC = 17,
+  EF_EASECUBIC = 18,
+  EF_EASEINQUART = 19,
+  EF_EASEOUTQUART = 20,
+  EF_EASEQUART = 21,
+  EF_EASEINQUINT = 22,
+  EF_EASEOUTQUINT = 23,
+  EF_EASEQUINT = 24,
+  EF_EASEINCIRC = 25,
+  EF_EASEOUTCIRC = 26,
+  EF_EASECIRC = 27,
+  EF_EASEINBACK = 28,
+  EF_EASEOUTBACK = 29,
+  EF_EASEBACK = 30,
+  UNRECOGNIZED = -1,
+}
+
+export function easingFunctionFromJSON(object: any): EasingFunction {
+  switch (object) {
+    case 0:
+    case "EF_LINEAR":
+      return EasingFunction.EF_LINEAR;
+    case 1:
+    case "EF_EASEINQUAD":
+      return EasingFunction.EF_EASEINQUAD;
+    case 2:
+    case "EF_EASEOUTQUAD":
+      return EasingFunction.EF_EASEOUTQUAD;
+    case 3:
+    case "EF_EASEQUAD":
+      return EasingFunction.EF_EASEQUAD;
+    case 4:
+    case "EF_EASEINSINE":
+      return EasingFunction.EF_EASEINSINE;
+    case 5:
+    case "EF_EASEOUTSINE":
+      return EasingFunction.EF_EASEOUTSINE;
+    case 6:
+    case "EF_EASESINE":
+      return EasingFunction.EF_EASESINE;
+    case 7:
+    case "EF_EASEINEXPO":
+      return EasingFunction.EF_EASEINEXPO;
+    case 8:
+    case "EF_EASEOUTEXPO":
+      return EasingFunction.EF_EASEOUTEXPO;
+    case 9:
+    case "EF_EASEEXPO":
+      return EasingFunction.EF_EASEEXPO;
+    case 10:
+    case "EF_EASEINELASTIC":
+      return EasingFunction.EF_EASEINELASTIC;
+    case 11:
+    case "EF_EASEOUTELASTIC":
+      return EasingFunction.EF_EASEOUTELASTIC;
+    case 12:
+    case "EF_EASEELASTIC":
+      return EasingFunction.EF_EASEELASTIC;
+    case 13:
+    case "EF_EASEINBOUNCE":
+      return EasingFunction.EF_EASEINBOUNCE;
+    case 14:
+    case "EF_EASEOUTBOUNCE":
+      return EasingFunction.EF_EASEOUTBOUNCE;
+    case 15:
+    case "EF_EASEBOUNCE":
+      return EasingFunction.EF_EASEBOUNCE;
+    case 16:
+    case "EF_EASEINCUBIC":
+      return EasingFunction.EF_EASEINCUBIC;
+    case 17:
+    case "EF_EASEOUTCUBIC":
+      return EasingFunction.EF_EASEOUTCUBIC;
+    case 18:
+    case "EF_EASECUBIC":
+      return EasingFunction.EF_EASECUBIC;
+    case 19:
+    case "EF_EASEINQUART":
+      return EasingFunction.EF_EASEINQUART;
+    case 20:
+    case "EF_EASEOUTQUART":
+      return EasingFunction.EF_EASEOUTQUART;
+    case 21:
+    case "EF_EASEQUART":
+      return EasingFunction.EF_EASEQUART;
+    case 22:
+    case "EF_EASEINQUINT":
+      return EasingFunction.EF_EASEINQUINT;
+    case 23:
+    case "EF_EASEOUTQUINT":
+      return EasingFunction.EF_EASEOUTQUINT;
+    case 24:
+    case "EF_EASEQUINT":
+      return EasingFunction.EF_EASEQUINT;
+    case 25:
+    case "EF_EASEINCIRC":
+      return EasingFunction.EF_EASEINCIRC;
+    case 26:
+    case "EF_EASEOUTCIRC":
+      return EasingFunction.EF_EASEOUTCIRC;
+    case 27:
+    case "EF_EASECIRC":
+      return EasingFunction.EF_EASECIRC;
+    case 28:
+    case "EF_EASEINBACK":
+      return EasingFunction.EF_EASEINBACK;
+    case 29:
+    case "EF_EASEOUTBACK":
+      return EasingFunction.EF_EASEOUTBACK;
+    case 30:
+    case "EF_EASEBACK":
+      return EasingFunction.EF_EASEBACK;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return EasingFunction.UNRECOGNIZED;
+  }
+}
+
+export function easingFunctionToJSON(object: EasingFunction): string {
+  switch (object) {
+    case EasingFunction.EF_LINEAR:
+      return "EF_LINEAR";
+    case EasingFunction.EF_EASEINQUAD:
+      return "EF_EASEINQUAD";
+    case EasingFunction.EF_EASEOUTQUAD:
+      return "EF_EASEOUTQUAD";
+    case EasingFunction.EF_EASEQUAD:
+      return "EF_EASEQUAD";
+    case EasingFunction.EF_EASEINSINE:
+      return "EF_EASEINSINE";
+    case EasingFunction.EF_EASEOUTSINE:
+      return "EF_EASEOUTSINE";
+    case EasingFunction.EF_EASESINE:
+      return "EF_EASESINE";
+    case EasingFunction.EF_EASEINEXPO:
+      return "EF_EASEINEXPO";
+    case EasingFunction.EF_EASEOUTEXPO:
+      return "EF_EASEOUTEXPO";
+    case EasingFunction.EF_EASEEXPO:
+      return "EF_EASEEXPO";
+    case EasingFunction.EF_EASEINELASTIC:
+      return "EF_EASEINELASTIC";
+    case EasingFunction.EF_EASEOUTELASTIC:
+      return "EF_EASEOUTELASTIC";
+    case EasingFunction.EF_EASEELASTIC:
+      return "EF_EASEELASTIC";
+    case EasingFunction.EF_EASEINBOUNCE:
+      return "EF_EASEINBOUNCE";
+    case EasingFunction.EF_EASEOUTBOUNCE:
+      return "EF_EASEOUTBOUNCE";
+    case EasingFunction.EF_EASEBOUNCE:
+      return "EF_EASEBOUNCE";
+    case EasingFunction.EF_EASEINCUBIC:
+      return "EF_EASEINCUBIC";
+    case EasingFunction.EF_EASEOUTCUBIC:
+      return "EF_EASEOUTCUBIC";
+    case EasingFunction.EF_EASECUBIC:
+      return "EF_EASECUBIC";
+    case EasingFunction.EF_EASEINQUART:
+      return "EF_EASEINQUART";
+    case EasingFunction.EF_EASEOUTQUART:
+      return "EF_EASEOUTQUART";
+    case EasingFunction.EF_EASEQUART:
+      return "EF_EASEQUART";
+    case EasingFunction.EF_EASEINQUINT:
+      return "EF_EASEINQUINT";
+    case EasingFunction.EF_EASEOUTQUINT:
+      return "EF_EASEOUTQUINT";
+    case EasingFunction.EF_EASEQUINT:
+      return "EF_EASEQUINT";
+    case EasingFunction.EF_EASEINCIRC:
+      return "EF_EASEINCIRC";
+    case EasingFunction.EF_EASEOUTCIRC:
+      return "EF_EASEOUTCIRC";
+    case EasingFunction.EF_EASECIRC:
+      return "EF_EASECIRC";
+    case EasingFunction.EF_EASEINBACK:
+      return "EF_EASEINBACK";
+    case EasingFunction.EF_EASEOUTBACK:
+      return "EF_EASEOUTBACK";
+    case EasingFunction.EF_EASEBACK:
+      return "EF_EASEBACK";
+    case EasingFunction.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface PBTween {
+  /** in milliseconds */
+  duration: number;
+  easingFunction: EasingFunction;
+  mode?:
+    | { $case: "move"; move: Move }
+    | { $case: "rotate"; rotate: Rotate }
+    | { $case: "scale"; scale: Scale }
+    | { $case: "textureMove"; textureMove: TextureMove }
+    | { $case: "rotateContinuous"; rotateContinuous: RotateContinuous }
+    | { $case: "moveContinuous"; moveContinuous: MoveContinuous }
+    | { $case: "textureMoveContinuous"; textureMoveContinuous: TextureMoveContinuous }
+    | { $case: "moveRotateScale"; moveRotateScale: MoveRotateScale }
+    | undefined;
+  /** default true (pause or running) */
+  playing?:
+    | boolean
+    | undefined;
+  /** between 0 and 1 */
+  currentTime?: number | undefined;
+}
+
+export interface Move {
+  start: Vector3 | undefined;
+  end: Vector3 | undefined;
+  faceDirection?: boolean | undefined;
+}
+
+export interface Rotate {
+  start: Quaternion | undefined;
+  end: Quaternion | undefined;
+}
+
+export interface Scale {
+  start: Vector3 | undefined;
+  end: Vector3 | undefined;
+}
+
+export interface MoveRotateScale {
+  positionStart: Vector3 | undefined;
+  positionEnd: Vector3 | undefined;
+  rotationStart: Quaternion | undefined;
+  rotationEnd: Quaternion | undefined;
+  scaleStart: Vector3 | undefined;
+  scaleEnd: Vector3 | undefined;
+}
+
+/**
+ * This tween mode allows to move the texture of a PbrMaterial or UnlitMaterial.
+ * You can also specify the movement type (offset or tiling)
+ */
+export interface TextureMove {
+  start: Vector2 | undefined;
+  end:
+    | Vector2
+    | undefined;
+  /** default = TextureMovementType.TMT_OFFSET */
+  movementType?: TextureMovementType | undefined;
+}
+
+export interface RotateContinuous {
+  direction: Quaternion | undefined;
+  speed: number;
+}
+
+export interface MoveContinuous {
+  direction: Vector3 | undefined;
+  speed: number;
+}
+
+export interface TextureMoveContinuous {
+  direction: Vector2 | undefined;
+  speed: number;
+  /** default = TextureMovementType.TMT_OFFSET */
+  movementType?: TextureMovementType | undefined;
+}
+
+function createBasePBTween(): PBTween {
+  return { duration: 0, easingFunction: 0, mode: undefined, playing: undefined, currentTime: undefined };
+}
+
+export namespace PBTween {
+  export function encode(message: PBTween, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.duration !== 0) {
+      writer.uint32(13).float(message.duration);
+    }
+    if (message.easingFunction !== 0) {
+      writer.uint32(16).int32(message.easingFunction);
+    }
+    switch (message.mode?.$case) {
+      case "move":
+        Move.encode(message.mode.move, writer.uint32(26).fork()).ldelim();
+        break;
+      case "rotate":
+        Rotate.encode(message.mode.rotate, writer.uint32(34).fork()).ldelim();
+        break;
+      case "scale":
+        Scale.encode(message.mode.scale, writer.uint32(42).fork()).ldelim();
+        break;
+      case "textureMove":
+        TextureMove.encode(message.mode.textureMove, writer.uint32(66).fork()).ldelim();
+        break;
+      case "rotateContinuous":
+        RotateContinuous.encode(message.mode.rotateContinuous, writer.uint32(74).fork()).ldelim();
+        break;
+      case "moveContinuous":
+        MoveContinuous.encode(message.mode.moveContinuous, writer.uint32(82).fork()).ldelim();
+        break;
+      case "textureMoveContinuous":
+        TextureMoveContinuous.encode(message.mode.textureMoveContinuous, writer.uint32(90).fork()).ldelim();
+        break;
+      case "moveRotateScale":
+        MoveRotateScale.encode(message.mode.moveRotateScale, writer.uint32(98).fork()).ldelim();
+        break;
+    }
+    if (message.playing !== undefined) {
+      writer.uint32(48).bool(message.playing);
+    }
+    if (message.currentTime !== undefined) {
+      writer.uint32(61).float(message.currentTime);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): PBTween {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePBTween();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 13) {
+            break;
+          }
+
+          message.duration = reader.float();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.easingFunction = reader.int32() as any;
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.mode = { $case: "move", move: Move.decode(reader, reader.uint32()) };
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.mode = { $case: "rotate", rotate: Rotate.decode(reader, reader.uint32()) };
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.mode = { $case: "scale", scale: Scale.decode(reader, reader.uint32()) };
+          continue;
+        case 8:
+          if (tag !== 66) {
+            break;
+          }
+
+          message.mode = { $case: "textureMove", textureMove: TextureMove.decode(reader, reader.uint32()) };
+          continue;
+        case 9:
+          if (tag !== 74) {
+            break;
+          }
+
+          message.mode = {
+            $case: "rotateContinuous",
+            rotateContinuous: RotateContinuous.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 10:
+          if (tag !== 82) {
+            break;
+          }
+
+          message.mode = { $case: "moveContinuous", moveContinuous: MoveContinuous.decode(reader, reader.uint32()) };
+          continue;
+        case 11:
+          if (tag !== 90) {
+            break;
+          }
+
+          message.mode = {
+            $case: "textureMoveContinuous",
+            textureMoveContinuous: TextureMoveContinuous.decode(reader, reader.uint32()),
+          };
+          continue;
+        case 12:
+          if (tag !== 98) {
+            break;
+          }
+
+          message.mode = { $case: "moveRotateScale", moveRotateScale: MoveRotateScale.decode(reader, reader.uint32()) };
+          continue;
+        case 6:
+          if (tag !== 48) {
+            break;
+          }
+
+          message.playing = reader.bool();
+          continue;
+        case 7:
+          if (tag !== 61) {
+            break;
+          }
+
+          message.currentTime = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): PBTween {
+    return {
+      duration: isSet(object.duration) ? Number(object.duration) : 0,
+      easingFunction: isSet(object.easingFunction) ? easingFunctionFromJSON(object.easingFunction) : 0,
+      mode: isSet(object.move)
+        ? { $case: "move", move: Move.fromJSON(object.move) }
+        : isSet(object.rotate)
+        ? { $case: "rotate", rotate: Rotate.fromJSON(object.rotate) }
+        : isSet(object.scale)
+        ? { $case: "scale", scale: Scale.fromJSON(object.scale) }
+        : isSet(object.textureMove)
+        ? { $case: "textureMove", textureMove: TextureMove.fromJSON(object.textureMove) }
+        : isSet(object.rotateContinuous)
+        ? { $case: "rotateContinuous", rotateContinuous: RotateContinuous.fromJSON(object.rotateContinuous) }
+        : isSet(object.moveContinuous)
+        ? { $case: "moveContinuous", moveContinuous: MoveContinuous.fromJSON(object.moveContinuous) }
+        : isSet(object.textureMoveContinuous)
+        ? {
+          $case: "textureMoveContinuous",
+          textureMoveContinuous: TextureMoveContinuous.fromJSON(object.textureMoveContinuous),
+        }
+        : isSet(object.moveRotateScale)
+        ? { $case: "moveRotateScale", moveRotateScale: MoveRotateScale.fromJSON(object.moveRotateScale) }
+        : undefined,
+      playing: isSet(object.playing) ? Boolean(object.playing) : undefined,
+      currentTime: isSet(object.currentTime) ? Number(object.currentTime) : undefined,
+    };
+  }
+
+  export function toJSON(message: PBTween): unknown {
+    const obj: any = {};
+    message.duration !== undefined && (obj.duration = message.duration);
+    message.easingFunction !== undefined && (obj.easingFunction = easingFunctionToJSON(message.easingFunction));
+    message.mode?.$case === "move" && (obj.move = message.mode?.move ? Move.toJSON(message.mode?.move) : undefined);
+    message.mode?.$case === "rotate" &&
+      (obj.rotate = message.mode?.rotate ? Rotate.toJSON(message.mode?.rotate) : undefined);
+    message.mode?.$case === "scale" &&
+      (obj.scale = message.mode?.scale ? Scale.toJSON(message.mode?.scale) : undefined);
+    message.mode?.$case === "textureMove" &&
+      (obj.textureMove = message.mode?.textureMove ? TextureMove.toJSON(message.mode?.textureMove) : undefined);
+    message.mode?.$case === "rotateContinuous" &&
+      (obj.rotateContinuous = message.mode?.rotateContinuous
+        ? RotateContinuous.toJSON(message.mode?.rotateContinuous)
+        : undefined);
+    message.mode?.$case === "moveContinuous" &&
+      (obj.moveContinuous = message.mode?.moveContinuous
+        ? MoveContinuous.toJSON(message.mode?.moveContinuous)
+        : undefined);
+    message.mode?.$case === "textureMoveContinuous" &&
+      (obj.textureMoveContinuous = message.mode?.textureMoveContinuous
+        ? TextureMoveContinuous.toJSON(message.mode?.textureMoveContinuous)
+        : undefined);
+    message.mode?.$case === "moveRotateScale" &&
+      (obj.moveRotateScale = message.mode?.moveRotateScale
+        ? MoveRotateScale.toJSON(message.mode?.moveRotateScale)
+        : undefined);
+    message.playing !== undefined && (obj.playing = message.playing);
+    message.currentTime !== undefined && (obj.currentTime = message.currentTime);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<PBTween>, I>>(base?: I): PBTween {
+    return PBTween.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<PBTween>, I>>(object: I): PBTween {
+    const message = createBasePBTween();
+    message.duration = object.duration ?? 0;
+    message.easingFunction = object.easingFunction ?? 0;
+    if (object.mode?.$case === "move" && object.mode?.move !== undefined && object.mode?.move !== null) {
+      message.mode = { $case: "move", move: Move.fromPartial(object.mode.move) };
+    }
+    if (object.mode?.$case === "rotate" && object.mode?.rotate !== undefined && object.mode?.rotate !== null) {
+      message.mode = { $case: "rotate", rotate: Rotate.fromPartial(object.mode.rotate) };
+    }
+    if (object.mode?.$case === "scale" && object.mode?.scale !== undefined && object.mode?.scale !== null) {
+      message.mode = { $case: "scale", scale: Scale.fromPartial(object.mode.scale) };
+    }
+    if (
+      object.mode?.$case === "textureMove" &&
+      object.mode?.textureMove !== undefined &&
+      object.mode?.textureMove !== null
+    ) {
+      message.mode = { $case: "textureMove", textureMove: TextureMove.fromPartial(object.mode.textureMove) };
+    }
+    if (
+      object.mode?.$case === "rotateContinuous" &&
+      object.mode?.rotateContinuous !== undefined &&
+      object.mode?.rotateContinuous !== null
+    ) {
+      message.mode = {
+        $case: "rotateContinuous",
+        rotateContinuous: RotateContinuous.fromPartial(object.mode.rotateContinuous),
+      };
+    }
+    if (
+      object.mode?.$case === "moveContinuous" &&
+      object.mode?.moveContinuous !== undefined &&
+      object.mode?.moveContinuous !== null
+    ) {
+      message.mode = {
+        $case: "moveContinuous",
+        moveContinuous: MoveContinuous.fromPartial(object.mode.moveContinuous),
+      };
+    }
+    if (
+      object.mode?.$case === "textureMoveContinuous" &&
+      object.mode?.textureMoveContinuous !== undefined &&
+      object.mode?.textureMoveContinuous !== null
+    ) {
+      message.mode = {
+        $case: "textureMoveContinuous",
+        textureMoveContinuous: TextureMoveContinuous.fromPartial(object.mode.textureMoveContinuous),
+      };
+    }
+    if (
+      object.mode?.$case === "moveRotateScale" &&
+      object.mode?.moveRotateScale !== undefined &&
+      object.mode?.moveRotateScale !== null
+    ) {
+      message.mode = {
+        $case: "moveRotateScale",
+        moveRotateScale: MoveRotateScale.fromPartial(object.mode.moveRotateScale),
+      };
+    }
+    message.playing = object.playing ?? undefined;
+    message.currentTime = object.currentTime ?? undefined;
+    return message;
+  }
+}
+
+function createBaseMove(): Move {
+  return { start: undefined, end: undefined, faceDirection: undefined };
+}
+
+export namespace Move {
+  export function encode(message: Move, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.start !== undefined) {
+      Vector3.encode(message.start, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.end !== undefined) {
+      Vector3.encode(message.end, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.faceDirection !== undefined) {
+      writer.uint32(24).bool(message.faceDirection);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Move {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMove();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.start = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.end = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.faceDirection = reader.bool();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Move {
+    return {
+      start: isSet(object.start) ? Vector3.fromJSON(object.start) : undefined,
+      end: isSet(object.end) ? Vector3.fromJSON(object.end) : undefined,
+      faceDirection: isSet(object.faceDirection) ? Boolean(object.faceDirection) : undefined,
+    };
+  }
+
+  export function toJSON(message: Move): unknown {
+    const obj: any = {};
+    message.start !== undefined && (obj.start = message.start ? Vector3.toJSON(message.start) : undefined);
+    message.end !== undefined && (obj.end = message.end ? Vector3.toJSON(message.end) : undefined);
+    message.faceDirection !== undefined && (obj.faceDirection = message.faceDirection);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Move>, I>>(base?: I): Move {
+    return Move.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Move>, I>>(object: I): Move {
+    const message = createBaseMove();
+    message.start = (object.start !== undefined && object.start !== null)
+      ? Vector3.fromPartial(object.start)
+      : undefined;
+    message.end = (object.end !== undefined && object.end !== null) ? Vector3.fromPartial(object.end) : undefined;
+    message.faceDirection = object.faceDirection ?? undefined;
+    return message;
+  }
+}
+
+function createBaseRotate(): Rotate {
+  return { start: undefined, end: undefined };
+}
+
+export namespace Rotate {
+  export function encode(message: Rotate, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.start !== undefined) {
+      Quaternion.encode(message.start, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.end !== undefined) {
+      Quaternion.encode(message.end, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Rotate {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRotate();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.start = Quaternion.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.end = Quaternion.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Rotate {
+    return {
+      start: isSet(object.start) ? Quaternion.fromJSON(object.start) : undefined,
+      end: isSet(object.end) ? Quaternion.fromJSON(object.end) : undefined,
+    };
+  }
+
+  export function toJSON(message: Rotate): unknown {
+    const obj: any = {};
+    message.start !== undefined && (obj.start = message.start ? Quaternion.toJSON(message.start) : undefined);
+    message.end !== undefined && (obj.end = message.end ? Quaternion.toJSON(message.end) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Rotate>, I>>(base?: I): Rotate {
+    return Rotate.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Rotate>, I>>(object: I): Rotate {
+    const message = createBaseRotate();
+    message.start = (object.start !== undefined && object.start !== null)
+      ? Quaternion.fromPartial(object.start)
+      : undefined;
+    message.end = (object.end !== undefined && object.end !== null) ? Quaternion.fromPartial(object.end) : undefined;
+    return message;
+  }
+}
+
+function createBaseScale(): Scale {
+  return { start: undefined, end: undefined };
+}
+
+export namespace Scale {
+  export function encode(message: Scale, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.start !== undefined) {
+      Vector3.encode(message.start, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.end !== undefined) {
+      Vector3.encode(message.end, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): Scale {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseScale();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.start = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.end = Vector3.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): Scale {
+    return {
+      start: isSet(object.start) ? Vector3.fromJSON(object.start) : undefined,
+      end: isSet(object.end) ? Vector3.fromJSON(object.end) : undefined,
+    };
+  }
+
+  export function toJSON(message: Scale): unknown {
+    const obj: any = {};
+    message.start !== undefined && (obj.start = message.start ? Vector3.toJSON(message.start) : undefined);
+    message.end !== undefined && (obj.end = message.end ? Vector3.toJSON(message.end) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<Scale>, I>>(base?: I): Scale {
+    return Scale.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<Scale>, I>>(object: I): Scale {
+    const message = createBaseScale();
+    message.start = (object.start !== undefined && object.start !== null)
+      ? Vector3.fromPartial(object.start)
+      : undefined;
+    message.end = (object.end !== undefined && object.end !== null) ? Vector3.fromPartial(object.end) : undefined;
+    return message;
+  }
+}
+
+function createBaseMoveRotateScale(): MoveRotateScale {
+  return {
+    positionStart: undefined,
+    positionEnd: undefined,
+    rotationStart: undefined,
+    rotationEnd: undefined,
+    scaleStart: undefined,
+    scaleEnd: undefined,
+  };
+}
+
+export namespace MoveRotateScale {
+  export function encode(message: MoveRotateScale, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.positionStart !== undefined) {
+      Vector3.encode(message.positionStart, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.positionEnd !== undefined) {
+      Vector3.encode(message.positionEnd, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.rotationStart !== undefined) {
+      Quaternion.encode(message.rotationStart, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.rotationEnd !== undefined) {
+      Quaternion.encode(message.rotationEnd, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.scaleStart !== undefined) {
+      Vector3.encode(message.scaleStart, writer.uint32(42).fork()).ldelim();
+    }
+    if (message.scaleEnd !== undefined) {
+      Vector3.encode(message.scaleEnd, writer.uint32(50).fork()).ldelim();
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): MoveRotateScale {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMoveRotateScale();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.positionStart = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.positionEnd = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.rotationStart = Quaternion.decode(reader, reader.uint32());
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.rotationEnd = Quaternion.decode(reader, reader.uint32());
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.scaleStart = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.scaleEnd = Vector3.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): MoveRotateScale {
+    return {
+      positionStart: isSet(object.positionStart) ? Vector3.fromJSON(object.positionStart) : undefined,
+      positionEnd: isSet(object.positionEnd) ? Vector3.fromJSON(object.positionEnd) : undefined,
+      rotationStart: isSet(object.rotationStart) ? Quaternion.fromJSON(object.rotationStart) : undefined,
+      rotationEnd: isSet(object.rotationEnd) ? Quaternion.fromJSON(object.rotationEnd) : undefined,
+      scaleStart: isSet(object.scaleStart) ? Vector3.fromJSON(object.scaleStart) : undefined,
+      scaleEnd: isSet(object.scaleEnd) ? Vector3.fromJSON(object.scaleEnd) : undefined,
+    };
+  }
+
+  export function toJSON(message: MoveRotateScale): unknown {
+    const obj: any = {};
+    message.positionStart !== undefined &&
+      (obj.positionStart = message.positionStart ? Vector3.toJSON(message.positionStart) : undefined);
+    message.positionEnd !== undefined &&
+      (obj.positionEnd = message.positionEnd ? Vector3.toJSON(message.positionEnd) : undefined);
+    message.rotationStart !== undefined &&
+      (obj.rotationStart = message.rotationStart ? Quaternion.toJSON(message.rotationStart) : undefined);
+    message.rotationEnd !== undefined &&
+      (obj.rotationEnd = message.rotationEnd ? Quaternion.toJSON(message.rotationEnd) : undefined);
+    message.scaleStart !== undefined &&
+      (obj.scaleStart = message.scaleStart ? Vector3.toJSON(message.scaleStart) : undefined);
+    message.scaleEnd !== undefined && (obj.scaleEnd = message.scaleEnd ? Vector3.toJSON(message.scaleEnd) : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<MoveRotateScale>, I>>(base?: I): MoveRotateScale {
+    return MoveRotateScale.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<MoveRotateScale>, I>>(object: I): MoveRotateScale {
+    const message = createBaseMoveRotateScale();
+    message.positionStart = (object.positionStart !== undefined && object.positionStart !== null)
+      ? Vector3.fromPartial(object.positionStart)
+      : undefined;
+    message.positionEnd = (object.positionEnd !== undefined && object.positionEnd !== null)
+      ? Vector3.fromPartial(object.positionEnd)
+      : undefined;
+    message.rotationStart = (object.rotationStart !== undefined && object.rotationStart !== null)
+      ? Quaternion.fromPartial(object.rotationStart)
+      : undefined;
+    message.rotationEnd = (object.rotationEnd !== undefined && object.rotationEnd !== null)
+      ? Quaternion.fromPartial(object.rotationEnd)
+      : undefined;
+    message.scaleStart = (object.scaleStart !== undefined && object.scaleStart !== null)
+      ? Vector3.fromPartial(object.scaleStart)
+      : undefined;
+    message.scaleEnd = (object.scaleEnd !== undefined && object.scaleEnd !== null)
+      ? Vector3.fromPartial(object.scaleEnd)
+      : undefined;
+    return message;
+  }
+}
+
+function createBaseTextureMove(): TextureMove {
+  return { start: undefined, end: undefined, movementType: undefined };
+}
+
+export namespace TextureMove {
+  export function encode(message: TextureMove, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.start !== undefined) {
+      Vector2.encode(message.start, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.end !== undefined) {
+      Vector2.encode(message.end, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.movementType !== undefined) {
+      writer.uint32(24).int32(message.movementType);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): TextureMove {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTextureMove();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.start = Vector2.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.end = Vector2.decode(reader, reader.uint32());
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.movementType = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): TextureMove {
+    return {
+      start: isSet(object.start) ? Vector2.fromJSON(object.start) : undefined,
+      end: isSet(object.end) ? Vector2.fromJSON(object.end) : undefined,
+      movementType: isSet(object.movementType) ? textureMovementTypeFromJSON(object.movementType) : undefined,
+    };
+  }
+
+  export function toJSON(message: TextureMove): unknown {
+    const obj: any = {};
+    message.start !== undefined && (obj.start = message.start ? Vector2.toJSON(message.start) : undefined);
+    message.end !== undefined && (obj.end = message.end ? Vector2.toJSON(message.end) : undefined);
+    message.movementType !== undefined &&
+      (obj.movementType = message.movementType !== undefined
+        ? textureMovementTypeToJSON(message.movementType)
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<TextureMove>, I>>(base?: I): TextureMove {
+    return TextureMove.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<TextureMove>, I>>(object: I): TextureMove {
+    const message = createBaseTextureMove();
+    message.start = (object.start !== undefined && object.start !== null)
+      ? Vector2.fromPartial(object.start)
+      : undefined;
+    message.end = (object.end !== undefined && object.end !== null) ? Vector2.fromPartial(object.end) : undefined;
+    message.movementType = object.movementType ?? undefined;
+    return message;
+  }
+}
+
+function createBaseRotateContinuous(): RotateContinuous {
+  return { direction: undefined, speed: 0 };
+}
+
+export namespace RotateContinuous {
+  export function encode(message: RotateContinuous, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.direction !== undefined) {
+      Quaternion.encode(message.direction, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.speed !== 0) {
+      writer.uint32(21).float(message.speed);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): RotateContinuous {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRotateContinuous();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.direction = Quaternion.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 21) {
+            break;
+          }
+
+          message.speed = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): RotateContinuous {
+    return {
+      direction: isSet(object.direction) ? Quaternion.fromJSON(object.direction) : undefined,
+      speed: isSet(object.speed) ? Number(object.speed) : 0,
+    };
+  }
+
+  export function toJSON(message: RotateContinuous): unknown {
+    const obj: any = {};
+    message.direction !== undefined &&
+      (obj.direction = message.direction ? Quaternion.toJSON(message.direction) : undefined);
+    message.speed !== undefined && (obj.speed = message.speed);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<RotateContinuous>, I>>(base?: I): RotateContinuous {
+    return RotateContinuous.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<RotateContinuous>, I>>(object: I): RotateContinuous {
+    const message = createBaseRotateContinuous();
+    message.direction = (object.direction !== undefined && object.direction !== null)
+      ? Quaternion.fromPartial(object.direction)
+      : undefined;
+    message.speed = object.speed ?? 0;
+    return message;
+  }
+}
+
+function createBaseMoveContinuous(): MoveContinuous {
+  return { direction: undefined, speed: 0 };
+}
+
+export namespace MoveContinuous {
+  export function encode(message: MoveContinuous, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.direction !== undefined) {
+      Vector3.encode(message.direction, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.speed !== 0) {
+      writer.uint32(21).float(message.speed);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): MoveContinuous {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMoveContinuous();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.direction = Vector3.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 21) {
+            break;
+          }
+
+          message.speed = reader.float();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): MoveContinuous {
+    return {
+      direction: isSet(object.direction) ? Vector3.fromJSON(object.direction) : undefined,
+      speed: isSet(object.speed) ? Number(object.speed) : 0,
+    };
+  }
+
+  export function toJSON(message: MoveContinuous): unknown {
+    const obj: any = {};
+    message.direction !== undefined &&
+      (obj.direction = message.direction ? Vector3.toJSON(message.direction) : undefined);
+    message.speed !== undefined && (obj.speed = message.speed);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<MoveContinuous>, I>>(base?: I): MoveContinuous {
+    return MoveContinuous.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<MoveContinuous>, I>>(object: I): MoveContinuous {
+    const message = createBaseMoveContinuous();
+    message.direction = (object.direction !== undefined && object.direction !== null)
+      ? Vector3.fromPartial(object.direction)
+      : undefined;
+    message.speed = object.speed ?? 0;
+    return message;
+  }
+}
+
+function createBaseTextureMoveContinuous(): TextureMoveContinuous {
+  return { direction: undefined, speed: 0, movementType: undefined };
+}
+
+export namespace TextureMoveContinuous {
+  export function encode(message: TextureMoveContinuous, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.direction !== undefined) {
+      Vector2.encode(message.direction, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.speed !== 0) {
+      writer.uint32(21).float(message.speed);
+    }
+    if (message.movementType !== undefined) {
+      writer.uint32(24).int32(message.movementType);
+    }
+    return writer;
+  }
+
+  export function decode(input: _m0.Reader | Uint8Array, length?: number): TextureMoveContinuous {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTextureMoveContinuous();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.direction = Vector2.decode(reader, reader.uint32());
+          continue;
+        case 2:
+          if (tag !== 21) {
+            break;
+          }
+
+          message.speed = reader.float();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.movementType = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  }
+
+  export function fromJSON(object: any): TextureMoveContinuous {
+    return {
+      direction: isSet(object.direction) ? Vector2.fromJSON(object.direction) : undefined,
+      speed: isSet(object.speed) ? Number(object.speed) : 0,
+      movementType: isSet(object.movementType) ? textureMovementTypeFromJSON(object.movementType) : undefined,
+    };
+  }
+
+  export function toJSON(message: TextureMoveContinuous): unknown {
+    const obj: any = {};
+    message.direction !== undefined &&
+      (obj.direction = message.direction ? Vector2.toJSON(message.direction) : undefined);
+    message.speed !== undefined && (obj.speed = message.speed);
+    message.movementType !== undefined &&
+      (obj.movementType = message.movementType !== undefined
+        ? textureMovementTypeToJSON(message.movementType)
+        : undefined);
+    return obj;
+  }
+
+  export function create<I extends Exact<DeepPartial<TextureMoveContinuous>, I>>(base?: I): TextureMoveContinuous {
+    return TextureMoveContinuous.fromPartial(base ?? {});
+  }
+
+  export function fromPartial<I extends Exact<DeepPartial<TextureMoveContinuous>, I>>(
+    object: I,
+  ): TextureMoveContinuous {
+    const message = createBaseTextureMoveContinuous();
+    message.direction = (object.direction !== undefined && object.direction !== null)
+      ? Vector2.fromPartial(object.direction)
+      : undefined;
+    message.speed = object.speed ?? 0;
+    message.movementType = object.movementType ?? 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;
+}