moons-ta-client 1.0.2 → 1.0.3

package/dist/models/packets.d.ts

@@ -0,0 +1,144 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Event } from './events.js';
+import { Response } from './responses.js';
+import { Request } from './requests.js';
+import { Push } from './pushes.js';
+import { Command } from './commands.js';
+/**
+ * ---- Backbone ---- //
+ *
+ * @generated from protobuf message proto.packets.Acknowledgement
+ */
+export interface Acknowledgement {
+    /**
+     * @generated from protobuf field: string packet_id = 1;
+     */
+    packetId: string;
+    /**
+     * @generated from protobuf field: proto.packets.Acknowledgement.AcknowledgementType type = 2;
+     */
+    type: Acknowledgement_AcknowledgementType;
+}
+/**
+ * @generated from protobuf enum proto.packets.Acknowledgement.AcknowledgementType
+ */
+export declare enum Acknowledgement_AcknowledgementType {
+    /**
+     * @generated from protobuf enum value: MessageReceived = 0;
+     */
+    MessageReceived = 0
+}
+/**
+ * @generated from protobuf message proto.packets.ForwardingPacket
+ */
+export interface ForwardingPacket {
+    /**
+     * @generated from protobuf field: repeated string forward_to = 1;
+     */
+    forwardTo: string[];
+    /**
+     * @generated from protobuf field: proto.packets.Packet packet = 2;
+     */
+    packet?: Packet;
+}
+/**
+ * @generated from protobuf message proto.packets.Packet
+ */
+export interface Packet {
+    /**
+     * @generated from protobuf field: string token = 1;
+     */
+    token: string;
+    /**
+     * @generated from protobuf field: string id = 2;
+     */
+    id: string;
+    /**
+     * @generated from protobuf field: string from = 3;
+     */
+    from: string;
+    /**
+     * @generated from protobuf oneof: packet
+     */
+    packet: {
+        oneofKind: "acknowledgement";
+        /**
+         * @generated from protobuf field: proto.packets.Acknowledgement acknowledgement = 4;
+         */
+        acknowledgement: Acknowledgement;
+    } | {
+        oneofKind: "forwardingPacket";
+        /**
+         * @generated from protobuf field: proto.packets.ForwardingPacket forwarding_packet = 5;
+         */
+        forwardingPacket: ForwardingPacket;
+    } | {
+        oneofKind: "command";
+        /**
+         * @generated from protobuf field: proto.packets.Command command = 6;
+         */
+        command: Command;
+    } | {
+        oneofKind: "push";
+        /**
+         * @generated from protobuf field: proto.packets.Push push = 7;
+         */
+        push: Push;
+    } | {
+        oneofKind: "request";
+        /**
+         * @generated from protobuf field: proto.packets.Request request = 8;
+         */
+        request: Request;
+    } | {
+        oneofKind: "response";
+        /**
+         * @generated from protobuf field: proto.packets.Response response = 9;
+         */
+        response: Response;
+    } | {
+        oneofKind: "event";
+        /**
+         * @generated from protobuf field: proto.packets.Event event = 10;
+         */
+        event: Event;
+    } | {
+        oneofKind: undefined;
+    };
+}
+declare class Acknowledgement$Type extends MessageType<Acknowledgement> {
+    constructor();
+    create(value?: PartialMessage<Acknowledgement>): Acknowledgement;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Acknowledgement): Acknowledgement;
+    internalBinaryWrite(message: Acknowledgement, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Acknowledgement
+ */
+export declare const Acknowledgement: Acknowledgement$Type;
+declare class ForwardingPacket$Type extends MessageType<ForwardingPacket> {
+    constructor();
+    create(value?: PartialMessage<ForwardingPacket>): ForwardingPacket;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ForwardingPacket): ForwardingPacket;
+    internalBinaryWrite(message: ForwardingPacket, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.ForwardingPacket
+ */
+export declare const ForwardingPacket: ForwardingPacket$Type;
+declare class Packet$Type extends MessageType<Packet> {
+    constructor();
+    create(value?: PartialMessage<Packet>): Packet;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Packet): Packet;
+    internalBinaryWrite(message: Packet, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Packet
+ */
+export declare const Packet: Packet$Type;
+export {};

package/{src/models/packets.ts → dist/models/packets.js}

@@ -1,13 +1,5 @@
-// @generated by protobuf-ts 2.8.2
-// @generated from protobuf file "packets.proto" (package "proto.packets", syntax proto3)
-// tslint:disable
-import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { IBinaryWriter } from "@protobuf-ts/runtime";
 import { WireType } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { IBinaryReader } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
-import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
 import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
@@ -16,124 +8,32 @@ import { Response } from './responses.js';
 import { Request } from './requests.js';
 import { Push } from './pushes.js';
 import { Command } from './commands.js';
-/**
- * ---- Backbone ---- //
- *
- * @generated from protobuf message proto.packets.Acknowledgement
- */
-export interface Acknowledgement {
-    /**
-     * @generated from protobuf field: string packet_id = 1;
-     */
-    packetId: string;
-    /**
-     * @generated from protobuf field: proto.packets.Acknowledgement.AcknowledgementType type = 2;
-     */
-    type: Acknowledgement_AcknowledgementType;
-}
 /**
  * @generated from protobuf enum proto.packets.Acknowledgement.AcknowledgementType
  */
-export enum Acknowledgement_AcknowledgementType {
+export var Acknowledgement_AcknowledgementType;
+(function (Acknowledgement_AcknowledgementType) {
     /**
      * @generated from protobuf enum value: MessageReceived = 0;
      */
-    MessageReceived = 0
-}
-/**
- * @generated from protobuf message proto.packets.ForwardingPacket
- */
-export interface ForwardingPacket {
-    /**
-     * @generated from protobuf field: repeated string forward_to = 1;
-     */
-    forwardTo: string[];
-    /**
-     * @generated from protobuf field: proto.packets.Packet packet = 2;
-     */
-    packet?: Packet;
-}
-/**
- * @generated from protobuf message proto.packets.Packet
- */
-export interface Packet {
-    /**
-     * @generated from protobuf field: string token = 1;
-     */
-    token: string;
-    /**
-     * @generated from protobuf field: string id = 2;
-     */
-    id: string;
-    /**
-     * @generated from protobuf field: string from = 3;
-     */
-    from: string;
-    /**
-     * @generated from protobuf oneof: packet
-     */
-    packet: {
-        oneofKind: "acknowledgement";
-        /**
-         * @generated from protobuf field: proto.packets.Acknowledgement acknowledgement = 4;
-         */
-        acknowledgement: Acknowledgement;
-    } | {
-        oneofKind: "forwardingPacket";
-        /**
-         * @generated from protobuf field: proto.packets.ForwardingPacket forwarding_packet = 5;
-         */
-        forwardingPacket: ForwardingPacket;
-    } | {
-        oneofKind: "command";
-        /**
-         * @generated from protobuf field: proto.packets.Command command = 6;
-         */
-        command: Command;
-    } | {
-        oneofKind: "push";
-        /**
-         * @generated from protobuf field: proto.packets.Push push = 7;
-         */
-        push: Push;
-    } | {
-        oneofKind: "request";
-        /**
-         * @generated from protobuf field: proto.packets.Request request = 8;
-         */
-        request: Request;
-    } | {
-        oneofKind: "response";
-        /**
-         * @generated from protobuf field: proto.packets.Response response = 9;
-         */
-        response: Response;
-    } | {
-        oneofKind: "event";
-        /**
-         * @generated from protobuf field: proto.packets.Event event = 10;
-         */
-        event: Event;
-    } | {
-        oneofKind: undefined;
-    };
-}
+    Acknowledgement_AcknowledgementType[Acknowledgement_AcknowledgementType["MessageReceived"] = 0] = "MessageReceived";
+})(Acknowledgement_AcknowledgementType = Acknowledgement_AcknowledgementType || (Acknowledgement_AcknowledgementType = {}));
 // @generated message type with reflection information, may provide speed optimized methods
-class Acknowledgement$Type extends MessageType<Acknowledgement> {
+class Acknowledgement$Type extends MessageType {
     constructor() {
         super("proto.packets.Acknowledgement", [
             { no: 1, name: "packet_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "type", kind: "enum", T: () => ["proto.packets.Acknowledgement.AcknowledgementType", Acknowledgement_AcknowledgementType] }
         ]);
     }
-    create(value?: PartialMessage<Acknowledgement>): Acknowledgement {
+    create(value) {
         const message = { packetId: "", type: 0 };
         globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial<Acknowledgement>(this, message, value);
+            reflectionMergePartial(this, message, value);
         return message;
     }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Acknowledgement): Acknowledgement {
+    internalBinaryRead(reader, length, options, target) {
         let message = target ?? this.create(), end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
@@ -155,7 +55,7 @@ class Acknowledgement$Type extends MessageType<Acknowledgement> {
         }
         return message;
     }
-    internalBinaryWrite(message: Acknowledgement, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+    internalBinaryWrite(message, writer, options) {
         /* string packet_id = 1; */
         if (message.packetId !== "")
             writer.tag(1, WireType.LengthDelimited).string(message.packetId);
@@ -173,21 +73,21 @@ class Acknowledgement$Type extends MessageType<Acknowledgement> {
  */
 export const Acknowledgement = new Acknowledgement$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class ForwardingPacket$Type extends MessageType<ForwardingPacket> {
+class ForwardingPacket$Type extends MessageType {
     constructor() {
         super("proto.packets.ForwardingPacket", [
             { no: 1, name: "forward_to", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "packet", kind: "message", T: () => Packet }
         ]);
     }
-    create(value?: PartialMessage<ForwardingPacket>): ForwardingPacket {
+    create(value) {
         const message = { forwardTo: [] };
         globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial<ForwardingPacket>(this, message, value);
+            reflectionMergePartial(this, message, value);
         return message;
     }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ForwardingPacket): ForwardingPacket {
+    internalBinaryRead(reader, length, options, target) {
         let message = target ?? this.create(), end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
@@ -209,7 +109,7 @@ class ForwardingPacket$Type extends MessageType<ForwardingPacket> {
         }
         return message;
     }
-    internalBinaryWrite(message: ForwardingPacket, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+    internalBinaryWrite(message, writer, options) {
         /* repeated string forward_to = 1; */
         for (let i = 0; i < message.forwardTo.length; i++)
             writer.tag(1, WireType.LengthDelimited).string(message.forwardTo[i]);
@@ -227,7 +127,7 @@ class ForwardingPacket$Type extends MessageType<ForwardingPacket> {
  */
 export const ForwardingPacket = new ForwardingPacket$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class Packet$Type extends MessageType<Packet> {
+class Packet$Type extends MessageType {
     constructor() {
         super("proto.packets.Packet", [
             { no: 1, name: "token", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
@@ -242,14 +142,14 @@ class Packet$Type extends MessageType<Packet> {
             { no: 10, name: "event", kind: "message", oneof: "packet", T: () => Event }
         ]);
     }
-    create(value?: PartialMessage<Packet>): Packet {
+    create(value) {
         const message = { token: "", id: "", from: "", packet: { oneofKind: undefined } };
         globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
         if (value !== undefined)
-            reflectionMergePartial<Packet>(this, message, value);
+            reflectionMergePartial(this, message, value);
         return message;
     }
-    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Packet): Packet {
+    internalBinaryRead(reader, length, options, target) {
         let message = target ?? this.create(), end = reader.pos + length;
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
@@ -266,43 +166,43 @@ class Packet$Type extends MessageType<Packet> {
                 case /* proto.packets.Acknowledgement acknowledgement */ 4:
                     message.packet = {
                         oneofKind: "acknowledgement",
-                        acknowledgement: Acknowledgement.internalBinaryRead(reader, reader.uint32(), options, (message.packet as any).acknowledgement)
+                        acknowledgement: Acknowledgement.internalBinaryRead(reader, reader.uint32(), options, message.packet.acknowledgement)
                     };
                     break;
                 case /* proto.packets.ForwardingPacket forwarding_packet */ 5:
                     message.packet = {
                         oneofKind: "forwardingPacket",
-                        forwardingPacket: ForwardingPacket.internalBinaryRead(reader, reader.uint32(), options, (message.packet as any).forwardingPacket)
+                        forwardingPacket: ForwardingPacket.internalBinaryRead(reader, reader.uint32(), options, message.packet.forwardingPacket)
                     };
                     break;
                 case /* proto.packets.Command command */ 6:
                     message.packet = {
                         oneofKind: "command",
-                        command: Command.internalBinaryRead(reader, reader.uint32(), options, (message.packet as any).command)
+                        command: Command.internalBinaryRead(reader, reader.uint32(), options, message.packet.command)
                     };
                     break;
                 case /* proto.packets.Push push */ 7:
                     message.packet = {
                         oneofKind: "push",
-                        push: Push.internalBinaryRead(reader, reader.uint32(), options, (message.packet as any).push)
+                        push: Push.internalBinaryRead(reader, reader.uint32(), options, message.packet.push)
                     };
                     break;
                 case /* proto.packets.Request request */ 8:
                     message.packet = {
                         oneofKind: "request",
-                        request: Request.internalBinaryRead(reader, reader.uint32(), options, (message.packet as any).request)
+                        request: Request.internalBinaryRead(reader, reader.uint32(), options, message.packet.request)
                     };
                     break;
                 case /* proto.packets.Response response */ 9:
                     message.packet = {
                         oneofKind: "response",
-                        response: Response.internalBinaryRead(reader, reader.uint32(), options, (message.packet as any).response)
+                        response: Response.internalBinaryRead(reader, reader.uint32(), options, message.packet.response)
                     };
                     break;
                 case /* proto.packets.Event event */ 10:
                     message.packet = {
                         oneofKind: "event",
-                        event: Event.internalBinaryRead(reader, reader.uint32(), options, (message.packet as any).event)
+                        event: Event.internalBinaryRead(reader, reader.uint32(), options, message.packet.event)
                     };
                     break;
                 default:
@@ -316,7 +216,7 @@ class Packet$Type extends MessageType<Packet> {
         }
         return message;
     }
-    internalBinaryWrite(message: Packet, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+    internalBinaryWrite(message, writer, options) {
         /* string token = 1; */
         if (message.token !== "")
             writer.tag(1, WireType.LengthDelimited).string(message.token);

package/dist/models/pushes.d.ts

@@ -0,0 +1,122 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Beatmap } from './models.js';
+import { User } from './models.js';
+import { RealtimeScore } from './models.js';
+/**
+ * ---- Pushes (SUBMIT something!) ---- //
+ *
+ * @generated from protobuf message proto.packets.Push
+ */
+export interface Push {
+    /**
+     * @generated from protobuf oneof: data
+     */
+    data: {
+        oneofKind: "realtimeScore";
+        /**
+         * @generated from protobuf field: proto.models.RealtimeScore realtime_score = 1;
+         */
+        realtimeScore: RealtimeScore;
+    } | {
+        oneofKind: "songFinished";
+        /**
+         * @generated from protobuf field: proto.packets.Push.SongFinished song_finished = 2;
+         */
+        songFinished: Push_SongFinished;
+    } | {
+        oneofKind: "discordAuthorized";
+        /**
+         * @generated from protobuf field: proto.packets.Push.DiscordAuthorized discord_authorized = 3;
+         */
+        discordAuthorized: Push_DiscordAuthorized;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message proto.packets.Push.SongFinished
+ */
+export interface Push_SongFinished {
+    /**
+     * @generated from protobuf field: proto.models.User player = 1;
+     */
+    player?: User;
+    /**
+     * @generated from protobuf field: proto.models.Beatmap beatmap = 2;
+     */
+    beatmap?: Beatmap;
+    /**
+     * @generated from protobuf field: proto.packets.Push.SongFinished.CompletionType type = 3;
+     */
+    type: Push_SongFinished_CompletionType;
+    /**
+     * @generated from protobuf field: int32 score = 4;
+     */
+    score: number;
+}
+/**
+ * @generated from protobuf enum proto.packets.Push.SongFinished.CompletionType
+ */
+export declare enum Push_SongFinished_CompletionType {
+    /**
+     * @generated from protobuf enum value: Passed = 0;
+     */
+    Passed = 0,
+    /**
+     * @generated from protobuf enum value: Failed = 1;
+     */
+    Failed = 1,
+    /**
+     * @generated from protobuf enum value: Quit = 2;
+     */
+    Quit = 2
+}
+/**
+ * @generated from protobuf message proto.packets.Push.DiscordAuthorized
+ */
+export interface Push_DiscordAuthorized {
+    /**
+     * @generated from protobuf field: bool success = 1;
+     */
+    success: boolean;
+    /**
+     * @generated from protobuf field: string token = 2;
+     */
+    token: string;
+}
+declare class Push$Type extends MessageType<Push> {
+    constructor();
+    create(value?: PartialMessage<Push>): Push;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Push): Push;
+    internalBinaryWrite(message: Push, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Push
+ */
+export declare const Push: Push$Type;
+declare class Push_SongFinished$Type extends MessageType<Push_SongFinished> {
+    constructor();
+    create(value?: PartialMessage<Push_SongFinished>): Push_SongFinished;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Push_SongFinished): Push_SongFinished;
+    internalBinaryWrite(message: Push_SongFinished, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Push.SongFinished
+ */
+export declare const Push_SongFinished: Push_SongFinished$Type;
+declare class Push_DiscordAuthorized$Type extends MessageType<Push_DiscordAuthorized> {
+    constructor();
+    create(value?: PartialMessage<Push_DiscordAuthorized>): Push_DiscordAuthorized;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Push_DiscordAuthorized): Push_DiscordAuthorized;
+    internalBinaryWrite(message: Push_DiscordAuthorized, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message proto.packets.Push.DiscordAuthorized
+ */
+export declare const Push_DiscordAuthorized: Push_DiscordAuthorized$Type;
+export {};