@devvit/protos 0.11.0-next-2024-07-24-e3a20f1a9.0 → 0.11.0-next-2024-07-25-e11c6b2a8.0

package/schema/.snootobuf/output/devenv_ts_files/devvit/plugin/logger/logger.ts

@@ -0,0 +1,608 @@
+// @generated by protobuf-ts 2.9.3
+// @generated from protobuf file "devvit/plugin/logger/logger.proto" (package "devvit.plugin.logger", syntax proto3)
+// tslint:disable
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+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 { MessageType } from "@protobuf-ts/runtime";
+import { Timestamp } from "../../../google/protobuf/timestamp";
+import { UInt32Value } from "../../../google/protobuf/wrappers";
+import { StringValue } from "../../../google/protobuf/wrappers";
+/**
+ * @generated from protobuf message devvit.plugin.logger.LogErrorMessage
+ */
+export interface LogErrorMessage {
+    /**
+     * @generated from protobuf field: string message = 1;
+     */
+    message: string;
+    /**
+     * @generated from protobuf field: string name = 2;
+     */
+    name: string;
+    /**
+     * @generated from protobuf field: google.protobuf.StringValue file_name = 3;
+     */
+    fileName?: StringValue;
+    /**
+     * @generated from protobuf field: google.protobuf.UInt32Value line_number = 4;
+     */
+    lineNumber?: UInt32Value;
+    /**
+     * @generated from protobuf field: google.protobuf.UInt32Value column_number = 5;
+     */
+    columnNumber?: UInt32Value;
+    /**
+     * @generated from protobuf field: google.protobuf.StringValue stack = 6;
+     */
+    stack?: StringValue;
+    /**
+     * @generated from protobuf field: google.protobuf.Timestamp timestamp = 7;
+     */
+    timestamp?: Timestamp;
+    /**
+     * to-do: add labels like LogEventMessage.
+     * Deprecated 2023-01-25: Use labels instead.
+     *
+     * @deprecated
+     * @generated from protobuf field: repeated string tags = 8 [deprecated = true];
+     */
+    tags: string[];
+}
+/**
+ * A notable event or historical record for analytics and security.
+ *
+ * Do not record sensitive data.
+ *
+ * @generated from protobuf message devvit.plugin.logger.LogEventMessage
+ */
+export interface LogEventMessage {
+    /**
+     * The event kind. Events with the same type are considered instances of that
+     * event. Eg, 'AppLoad' or 'AppHTTPRequest'.
+     *
+     * Unexpected event types may not be logged.
+     *
+     * @generated from protobuf field: string type = 1;
+     */
+    type: string;
+    /**
+     * * The occurence time.
+     *
+     * @generated from protobuf field: google.protobuf.Timestamp timestamp = 2;
+     */
+    timestamp?: Timestamp;
+    /**
+     * Optional additional indexed information. Eg, 'direction' → 'Up' or
+     * 'appName' → 'com.example.test'.
+     *
+     * Unexpected label keys may be stripped.
+     *
+     * Labels and data are the same except that labels are indexed.
+     *
+     * @generated from protobuf field: map<string, string> labels = 3;
+     */
+    labels: {
+        [key: string]: string;
+    };
+    /**
+     * Optional additional non-indexed information. Eg, 'dynamicString' → 'abc'
+     * 'verboseDetail' -> '123'.
+     *
+     * Any key-value may safely be included without coordination.
+     *
+     * Labels and data are the same except that labels are indexed.
+     *
+     * @generated from protobuf field: map<string, string> data = 4;
+     */
+    data: {
+        [key: string]: string;
+    };
+}
+/**
+ * @generated from protobuf message devvit.plugin.logger.LogMessage
+ */
+export interface LogMessage {
+    /**
+     * @generated from protobuf field: devvit.plugin.logger.Severity severity = 1;
+     */
+    severity: Severity;
+    /**
+     * @generated from protobuf field: string message = 2;
+     */
+    message: string;
+    /**
+     * Most service implementations default to call time if a timestamp is not
+     * provided.
+     *
+     * @generated from protobuf field: google.protobuf.Timestamp timestamp = 3;
+     */
+    timestamp?: Timestamp;
+    /**
+     * to-do: add labels like LogEventMessage.
+     * Deprecated 2023-01-25: Use labels instead.
+     *
+     * @deprecated
+     * @generated from protobuf field: repeated string tags = 4 [deprecated = true];
+     */
+    tags: string[];
+}
+/**
+ * @generated from protobuf message devvit.plugin.logger.LogMessages
+ */
+export interface LogMessages {
+    /**
+     * @generated from protobuf field: repeated devvit.plugin.logger.LogMessage messages = 1;
+     */
+    messages: LogMessage[];
+}
+/**
+ * @generated from protobuf message devvit.plugin.logger.LogErrorResponse
+ */
+export interface LogErrorResponse {
+}
+/**
+ * @generated from protobuf message devvit.plugin.logger.LogEventResponse
+ */
+export interface LogEventResponse {
+}
+/**
+ * @generated from protobuf message devvit.plugin.logger.LogResponse
+ */
+export interface LogResponse {
+}
+/**
+ * @generated from protobuf enum devvit.plugin.logger.Severity
+ */
+export enum Severity {
+    /**
+     * Debug logs should never be committed.
+     *
+     * These logs are always enabled in development builds but disabled in
+     * production.
+     *
+     * @generated from protobuf enum value: DEBUG = 0;
+     */
+    DEBUG = 0,
+    /**
+     * Informational logs should be used to mark significant non-erroneous events.
+     * Little information is significant.
+     *
+     * These logs are enabled by default in development builds but may be
+     * disabled in production.
+     *
+     * @generated from protobuf enum value: INFO = 1;
+     */
+    INFO = 1,
+    /**
+     * Warnings should be reported as long as they do not contain sensitive data.
+     *
+     * These logs are always enabled.
+     *
+     * @generated from protobuf enum value: WARN = 2;
+     */
+    WARN = 2,
+    /**
+     * Errors should always be reported as long as they do not contain sensitive
+     * data.
+     *
+     * @generated from protobuf enum value: ERROR = 3;
+     */
+    ERROR = 3,
+    /**
+     * Verbose logs are useful for tracing but usually a hindrance for others not
+     * working where the log is placed. Keep our logs clean and add with care.
+     *
+     * These logs are disabled by default in all environments but can be enabled.
+     *
+     * @generated from protobuf enum value: VERBOSE = 4;
+     */
+    VERBOSE = 4
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class LogErrorMessage$Type extends MessageType<LogErrorMessage> {
+    constructor() {
+        super("devvit.plugin.logger.LogErrorMessage", [
+            { no: 1, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "file_name", kind: "message", T: () => StringValue },
+            { no: 4, name: "line_number", kind: "message", T: () => UInt32Value },
+            { no: 5, name: "column_number", kind: "message", T: () => UInt32Value },
+            { no: 6, name: "stack", kind: "message", T: () => StringValue },
+            { no: 7, name: "timestamp", kind: "message", T: () => Timestamp },
+            { no: 8, name: "tags", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<LogErrorMessage>): LogErrorMessage {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.message = "";
+        message.name = "";
+        message.tags = [];
+        if (value !== undefined)
+            reflectionMergePartial<LogErrorMessage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogErrorMessage): LogErrorMessage {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string message */ 1:
+                    message.message = reader.string();
+                    break;
+                case /* string name */ 2:
+                    message.name = reader.string();
+                    break;
+                case /* google.protobuf.StringValue file_name */ 3:
+                    message.fileName = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.fileName);
+                    break;
+                case /* google.protobuf.UInt32Value line_number */ 4:
+                    message.lineNumber = UInt32Value.internalBinaryRead(reader, reader.uint32(), options, message.lineNumber);
+                    break;
+                case /* google.protobuf.UInt32Value column_number */ 5:
+                    message.columnNumber = UInt32Value.internalBinaryRead(reader, reader.uint32(), options, message.columnNumber);
+                    break;
+                case /* google.protobuf.StringValue stack */ 6:
+                    message.stack = StringValue.internalBinaryRead(reader, reader.uint32(), options, message.stack);
+                    break;
+                case /* google.protobuf.Timestamp timestamp */ 7:
+                    message.timestamp = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.timestamp);
+                    break;
+                case /* repeated string tags = 8 [deprecated = true];*/ 8:
+                    message.tags.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: LogErrorMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string message = 1; */
+        if (message.message !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.message);
+        /* string name = 2; */
+        if (message.name !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.name);
+        /* google.protobuf.StringValue file_name = 3; */
+        if (message.fileName)
+            StringValue.internalBinaryWrite(message.fileName, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.UInt32Value line_number = 4; */
+        if (message.lineNumber)
+            UInt32Value.internalBinaryWrite(message.lineNumber, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.UInt32Value column_number = 5; */
+        if (message.columnNumber)
+            UInt32Value.internalBinaryWrite(message.columnNumber, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.StringValue stack = 6; */
+        if (message.stack)
+            StringValue.internalBinaryWrite(message.stack, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp timestamp = 7; */
+        if (message.timestamp)
+            Timestamp.internalBinaryWrite(message.timestamp, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string tags = 8 [deprecated = true]; */
+        for (let i = 0; i < message.tags.length; i++)
+            writer.tag(8, WireType.LengthDelimited).string(message.tags[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.logger.LogErrorMessage
+ */
+export const LogErrorMessage = new LogErrorMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LogEventMessage$Type extends MessageType<LogEventMessage> {
+    constructor() {
+        super("devvit.plugin.logger.LogEventMessage", [
+            { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "timestamp", kind: "message", T: () => Timestamp },
+            { no: 3, name: "labels", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } },
+            { no: 4, name: "data", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } }
+        ]);
+    }
+    create(value?: PartialMessage<LogEventMessage>): LogEventMessage {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.type = "";
+        message.labels = {};
+        message.data = {};
+        if (value !== undefined)
+            reflectionMergePartial<LogEventMessage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogEventMessage): LogEventMessage {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string type */ 1:
+                    message.type = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp timestamp */ 2:
+                    message.timestamp = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.timestamp);
+                    break;
+                case /* map<string, string> labels */ 3:
+                    this.binaryReadMap3(message.labels, reader, options);
+                    break;
+                case /* map<string, string> data */ 4:
+                    this.binaryReadMap4(message.data, reader, options);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    private binaryReadMap3(map: LogEventMessage["labels"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof LogEventMessage["labels"] | undefined, val: LogEventMessage["labels"][any] | undefined;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = reader.string();
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for field devvit.plugin.logger.LogEventMessage.labels");
+            }
+        }
+        map[key ?? ""] = val ?? "";
+    }
+    private binaryReadMap4(map: LogEventMessage["data"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof LogEventMessage["data"] | undefined, val: LogEventMessage["data"][any] | undefined;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = reader.string();
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for field devvit.plugin.logger.LogEventMessage.data");
+            }
+        }
+        map[key ?? ""] = val ?? "";
+    }
+    internalBinaryWrite(message: LogEventMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string type = 1; */
+        if (message.type !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.type);
+        /* google.protobuf.Timestamp timestamp = 2; */
+        if (message.timestamp)
+            Timestamp.internalBinaryWrite(message.timestamp, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* map<string, string> labels = 3; */
+        for (let k of globalThis.Object.keys(message.labels))
+            writer.tag(3, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.labels[k]).join();
+        /* map<string, string> data = 4; */
+        for (let k of globalThis.Object.keys(message.data))
+            writer.tag(4, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.data[k]).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.logger.LogEventMessage
+ */
+export const LogEventMessage = new LogEventMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LogMessage$Type extends MessageType<LogMessage> {
+    constructor() {
+        super("devvit.plugin.logger.LogMessage", [
+            { no: 1, name: "severity", kind: "enum", T: () => ["devvit.plugin.logger.Severity", Severity] },
+            { no: 2, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "timestamp", kind: "message", T: () => Timestamp },
+            { no: 4, name: "tags", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<LogMessage>): LogMessage {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.severity = 0;
+        message.message = "";
+        message.tags = [];
+        if (value !== undefined)
+            reflectionMergePartial<LogMessage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogMessage): LogMessage {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.logger.Severity severity */ 1:
+                    message.severity = reader.int32();
+                    break;
+                case /* string message */ 2:
+                    message.message = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp timestamp */ 3:
+                    message.timestamp = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.timestamp);
+                    break;
+                case /* repeated string tags = 4 [deprecated = true];*/ 4:
+                    message.tags.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: LogMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.logger.Severity severity = 1; */
+        if (message.severity !== 0)
+            writer.tag(1, WireType.Varint).int32(message.severity);
+        /* string message = 2; */
+        if (message.message !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.message);
+        /* google.protobuf.Timestamp timestamp = 3; */
+        if (message.timestamp)
+            Timestamp.internalBinaryWrite(message.timestamp, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string tags = 4 [deprecated = true]; */
+        for (let i = 0; i < message.tags.length; i++)
+            writer.tag(4, WireType.LengthDelimited).string(message.tags[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.logger.LogMessage
+ */
+export const LogMessage = new LogMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LogMessages$Type extends MessageType<LogMessages> {
+    constructor() {
+        super("devvit.plugin.logger.LogMessages", [
+            { no: 1, name: "messages", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => LogMessage }
+        ]);
+    }
+    create(value?: PartialMessage<LogMessages>): LogMessages {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.messages = [];
+        if (value !== undefined)
+            reflectionMergePartial<LogMessages>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogMessages): LogMessages {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated devvit.plugin.logger.LogMessage messages */ 1:
+                    message.messages.push(LogMessage.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: LogMessages, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated devvit.plugin.logger.LogMessage messages = 1; */
+        for (let i = 0; i < message.messages.length; i++)
+            LogMessage.internalBinaryWrite(message.messages[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.logger.LogMessages
+ */
+export const LogMessages = new LogMessages$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LogErrorResponse$Type extends MessageType<LogErrorResponse> {
+    constructor() {
+        super("devvit.plugin.logger.LogErrorResponse", []);
+    }
+    create(value?: PartialMessage<LogErrorResponse>): LogErrorResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<LogErrorResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogErrorResponse): LogErrorResponse {
+        return target ?? this.create();
+    }
+    internalBinaryWrite(message: LogErrorResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.logger.LogErrorResponse
+ */
+export const LogErrorResponse = new LogErrorResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LogEventResponse$Type extends MessageType<LogEventResponse> {
+    constructor() {
+        super("devvit.plugin.logger.LogEventResponse", []);
+    }
+    create(value?: PartialMessage<LogEventResponse>): LogEventResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<LogEventResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogEventResponse): LogEventResponse {
+        return target ?? this.create();
+    }
+    internalBinaryWrite(message: LogEventResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.logger.LogEventResponse
+ */
+export const LogEventResponse = new LogEventResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LogResponse$Type extends MessageType<LogResponse> {
+    constructor() {
+        super("devvit.plugin.logger.LogResponse", []);
+    }
+    create(value?: PartialMessage<LogResponse>): LogResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<LogResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LogResponse): LogResponse {
+        return target ?? this.create();
+    }
+    internalBinaryWrite(message: LogResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.plugin.logger.LogResponse
+ */
+export const LogResponse = new LogResponse$Type();
+/**
+ * @generated ServiceType for protobuf service devvit.plugin.logger.Logger
+ */
+export const Logger = new ServiceType("devvit.plugin.logger.Logger", [
+    { name: "Error", options: {}, I: LogErrorMessage, O: LogErrorResponse },
+    { name: "Event", options: {}, I: LogEventMessage, O: LogEventResponse },
+    { name: "Log", options: {}, I: LogMessage, O: LogResponse },
+    { name: "LogBatch", options: {}, I: LogMessages, O: LogResponse }
+]);

package/schema/.snootobuf/output/devenv_ts_files/devvit/plugin/media/media.client.ts

@@ -0,0 +1,37 @@
+// @generated by protobuf-ts 2.9.3
+// @generated from protobuf file "devvit/plugin/media/media.proto" (package "devvit.plugin.media", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { MediaService } from "./media";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { MediaUploadResponse } from "./media";
+import type { MediaUploadRequest } from "./media";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service devvit.plugin.media.MediaService
+ */
+export interface IMediaServiceClient {
+    /**
+     * @generated from protobuf rpc: Upload(devvit.plugin.media.MediaUploadRequest) returns (devvit.plugin.media.MediaUploadResponse);
+     */
+    upload(input: MediaUploadRequest, options?: RpcOptions): UnaryCall<MediaUploadRequest, MediaUploadResponse>;
+}
+/**
+ * @generated from protobuf service devvit.plugin.media.MediaService
+ */
+export class MediaServiceClient implements IMediaServiceClient, ServiceInfo {
+    typeName = MediaService.typeName;
+    methods = MediaService.methods;
+    options = MediaService.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Upload(devvit.plugin.media.MediaUploadRequest) returns (devvit.plugin.media.MediaUploadResponse);
+     */
+    upload(input: MediaUploadRequest, options?: RpcOptions): UnaryCall<MediaUploadRequest, MediaUploadResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<MediaUploadRequest, MediaUploadResponse>("unary", this._transport, method, opt, input);
+    }
+}