@devvit/protos 0.11.0-next-2024-07-24-1be38cc96.0 → 0.11.0-next-2024-07-25-1378e6e47.0

package/schema/.snootobuf/output/devenv_ts_files/devvit/remote_logger/remote_logger.client.ts

@@ -0,0 +1,78 @@
+// @generated by protobuf-ts 2.9.3
+// @generated from protobuf file "devvit/remote_logger/remote_logger.proto" (package "devvit.remote_logger", syntax proto3)
+// tslint:disable
+import { RemoteLogConsumer } from "./remote_logger";
+import type { RemoteLogQuery } from "./remote_logger";
+import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { RemoteLogPublisher } from "./remote_logger";
+import type { RemoteLogMessages } from "./remote_logger";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { RemoteLogPutResponse } from "./remote_logger";
+import type { RemoteLogMessage } from "./remote_logger";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service devvit.remote_logger.RemoteLogPublisher
+ */
+export interface IRemoteLogPublisherClient {
+    /**
+     * @generated from protobuf rpc: Put(devvit.remote_logger.RemoteLogMessage) returns (devvit.remote_logger.RemoteLogPutResponse);
+     */
+    put(input: RemoteLogMessage, options?: RpcOptions): UnaryCall<RemoteLogMessage, RemoteLogPutResponse>;
+    /**
+     * @generated from protobuf rpc: PutAll(devvit.remote_logger.RemoteLogMessages) returns (devvit.remote_logger.RemoteLogPutResponse);
+     */
+    putAll(input: RemoteLogMessages, options?: RpcOptions): UnaryCall<RemoteLogMessages, RemoteLogPutResponse>;
+}
+/**
+ * @generated from protobuf service devvit.remote_logger.RemoteLogPublisher
+ */
+export class RemoteLogPublisherClient implements IRemoteLogPublisherClient, ServiceInfo {
+    typeName = RemoteLogPublisher.typeName;
+    methods = RemoteLogPublisher.methods;
+    options = RemoteLogPublisher.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Put(devvit.remote_logger.RemoteLogMessage) returns (devvit.remote_logger.RemoteLogPutResponse);
+     */
+    put(input: RemoteLogMessage, options?: RpcOptions): UnaryCall<RemoteLogMessage, RemoteLogPutResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<RemoteLogMessage, RemoteLogPutResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: PutAll(devvit.remote_logger.RemoteLogMessages) returns (devvit.remote_logger.RemoteLogPutResponse);
+     */
+    putAll(input: RemoteLogMessages, options?: RpcOptions): UnaryCall<RemoteLogMessages, RemoteLogPutResponse> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<RemoteLogMessages, RemoteLogPutResponse>("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service devvit.remote_logger.RemoteLogConsumer
+ */
+export interface IRemoteLogConsumerClient {
+    /**
+     * @generated from protobuf rpc: Tail(devvit.remote_logger.RemoteLogQuery) returns (stream devvit.remote_logger.RemoteLogMessage);
+     */
+    tail(input: RemoteLogQuery, options?: RpcOptions): ServerStreamingCall<RemoteLogQuery, RemoteLogMessage>;
+}
+/**
+ * @generated from protobuf service devvit.remote_logger.RemoteLogConsumer
+ */
+export class RemoteLogConsumerClient implements IRemoteLogConsumerClient, ServiceInfo {
+    typeName = RemoteLogConsumer.typeName;
+    methods = RemoteLogConsumer.methods;
+    options = RemoteLogConsumer.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: Tail(devvit.remote_logger.RemoteLogQuery) returns (stream devvit.remote_logger.RemoteLogMessage);
+     */
+    tail(input: RemoteLogQuery, options?: RpcOptions): ServerStreamingCall<RemoteLogQuery, RemoteLogMessage> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<RemoteLogQuery, RemoteLogMessage>("serverStreaming", this._transport, method, opt, input);
+    }
+}

package/schema/.snootobuf/output/devenv_ts_files/devvit/remote_logger/remote_logger.ts

@@ -0,0 +1,538 @@
+// @generated by protobuf-ts 2.9.3
+// @generated from protobuf file "devvit/remote_logger/remote_logger.proto" (package "devvit.remote_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 { LogEventMessage } from "../plugin/logger/logger";
+import { LogErrorMessage } from "../plugin/logger/logger";
+import { LogMessage } from "../plugin/logger/logger";
+import { Timestamp } from "../../google/protobuf/timestamp";
+/**
+ * @generated from protobuf message devvit.remote_logger.RemoteLogMessages
+ */
+export interface RemoteLogMessages {
+    /**
+     * @generated from protobuf field: repeated devvit.remote_logger.RemoteLogMessage messages = 1;
+     */
+    messages: RemoteLogMessage[];
+}
+/**
+ * @generated from protobuf message devvit.remote_logger.RemoteLogPutResponse
+ */
+export interface RemoteLogPutResponse {
+}
+/**
+ * @generated from protobuf message devvit.remote_logger.KeepAliveMessage
+ */
+export interface KeepAliveMessage {
+    /**
+     * @generated from protobuf field: google.protobuf.Timestamp timestamp = 1;
+     */
+    timestamp?: Timestamp;
+}
+/**
+ * @generated from protobuf message devvit.remote_logger.RemoteLogMessage
+ */
+export interface RemoteLogMessage {
+    /**
+     * @generated from protobuf oneof: message
+     */
+    message: {
+        oneofKind: "log";
+        /**
+         * @generated from protobuf field: devvit.plugin.logger.LogMessage log = 1;
+         */
+        log: LogMessage;
+    } | {
+        oneofKind: "error";
+        /**
+         * @generated from protobuf field: devvit.plugin.logger.LogErrorMessage error = 2;
+         */
+        error: LogErrorMessage;
+    } | {
+        oneofKind: "keepalive";
+        /**
+         * @generated from protobuf field: devvit.remote_logger.KeepAliveMessage keepalive = 3;
+         */
+        keepalive: KeepAliveMessage;
+    } | {
+        oneofKind: "event";
+        /**
+         * @generated from protobuf field: devvit.plugin.logger.LogEventMessage event = 4;
+         */
+        event: LogEventMessage;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * Filter on installation ID (encoded subreddit name AND app name).
+ *
+ * @generated from protobuf message devvit.remote_logger.RemoteLogInstallationFilter
+ */
+export interface RemoteLogInstallationFilter {
+    /**
+     * @generated from protobuf field: string installation_id = 1;
+     */
+    installationId: string;
+}
+/**
+ * Filter on subreddit name and / or app name. Not all combinations are
+ * available on all streams.
+ *
+ * @generated from protobuf message devvit.remote_logger.RemoteLogSubredditAppNameFilter
+ */
+export interface RemoteLogSubredditAppNameFilter {
+    /**
+     * @generated from protobuf field: string subreddit = 2;
+     */
+    subreddit: string;
+    /**
+     * @generated from protobuf field: string app_name = 3;
+     */
+    appName: string;
+}
+/**
+ * @generated from protobuf message devvit.remote_logger.RemoteLogQuery
+ */
+export interface RemoteLogQuery {
+    /**
+     * @generated from protobuf oneof: filter
+     */
+    filter: {
+        oneofKind: "installation";
+        /**
+         * @generated from protobuf field: devvit.remote_logger.RemoteLogInstallationFilter installation = 1;
+         */
+        installation: RemoteLogInstallationFilter;
+    } | {
+        oneofKind: "subredditAppName";
+        /**
+         * @generated from protobuf field: devvit.remote_logger.RemoteLogSubredditAppNameFilter subreddit_app_name = 2;
+         */
+        subredditAppName: RemoteLogSubredditAppNameFilter;
+    } | {
+        oneofKind: undefined;
+    };
+    /**
+     * @generated from protobuf field: devvit.remote_logger.RemoteLogType type = 3;
+     */
+    type: RemoteLogType;
+    /**
+     * @generated from protobuf field: google.protobuf.Timestamp since = 4;
+     */
+    since?: Timestamp;
+}
+/**
+ * @generated from protobuf enum devvit.remote_logger.RemoteLogType
+ */
+export enum RemoteLogType {
+    /**
+     * @generated from protobuf enum value: LOG = 0;
+     */
+    LOG = 0,
+    /**
+     * @generated from protobuf enum value: ERROR = 1;
+     */
+    ERROR = 1,
+    /**
+     * @generated from protobuf enum value: EVENT = 2;
+     */
+    EVENT = 2
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoteLogMessages$Type extends MessageType<RemoteLogMessages> {
+    constructor() {
+        super("devvit.remote_logger.RemoteLogMessages", [
+            { no: 1, name: "messages", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => RemoteLogMessage }
+        ]);
+    }
+    create(value?: PartialMessage<RemoteLogMessages>): RemoteLogMessages {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.messages = [];
+        if (value !== undefined)
+            reflectionMergePartial<RemoteLogMessages>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoteLogMessages): RemoteLogMessages {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated devvit.remote_logger.RemoteLogMessage messages */ 1:
+                    message.messages.push(RemoteLogMessage.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: RemoteLogMessages, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated devvit.remote_logger.RemoteLogMessage messages = 1; */
+        for (let i = 0; i < message.messages.length; i++)
+            RemoteLogMessage.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.remote_logger.RemoteLogMessages
+ */
+export const RemoteLogMessages = new RemoteLogMessages$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoteLogPutResponse$Type extends MessageType<RemoteLogPutResponse> {
+    constructor() {
+        super("devvit.remote_logger.RemoteLogPutResponse", []);
+    }
+    create(value?: PartialMessage<RemoteLogPutResponse>): RemoteLogPutResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<RemoteLogPutResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoteLogPutResponse): RemoteLogPutResponse {
+        return target ?? this.create();
+    }
+    internalBinaryWrite(message: RemoteLogPutResponse, 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.remote_logger.RemoteLogPutResponse
+ */
+export const RemoteLogPutResponse = new RemoteLogPutResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class KeepAliveMessage$Type extends MessageType<KeepAliveMessage> {
+    constructor() {
+        super("devvit.remote_logger.KeepAliveMessage", [
+            { no: 1, name: "timestamp", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value?: PartialMessage<KeepAliveMessage>): KeepAliveMessage {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<KeepAliveMessage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: KeepAliveMessage): KeepAliveMessage {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* google.protobuf.Timestamp timestamp */ 1:
+                    message.timestamp = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.timestamp);
+                    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: KeepAliveMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* google.protobuf.Timestamp timestamp = 1; */
+        if (message.timestamp)
+            Timestamp.internalBinaryWrite(message.timestamp, 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.remote_logger.KeepAliveMessage
+ */
+export const KeepAliveMessage = new KeepAliveMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoteLogMessage$Type extends MessageType<RemoteLogMessage> {
+    constructor() {
+        super("devvit.remote_logger.RemoteLogMessage", [
+            { no: 1, name: "log", kind: "message", oneof: "message", T: () => LogMessage },
+            { no: 2, name: "error", kind: "message", oneof: "message", T: () => LogErrorMessage },
+            { no: 3, name: "keepalive", kind: "message", oneof: "message", T: () => KeepAliveMessage },
+            { no: 4, name: "event", kind: "message", oneof: "message", T: () => LogEventMessage }
+        ]);
+    }
+    create(value?: PartialMessage<RemoteLogMessage>): RemoteLogMessage {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.message = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<RemoteLogMessage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoteLogMessage): RemoteLogMessage {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.plugin.logger.LogMessage log */ 1:
+                    message.message = {
+                        oneofKind: "log",
+                        log: LogMessage.internalBinaryRead(reader, reader.uint32(), options, (message.message as any).log)
+                    };
+                    break;
+                case /* devvit.plugin.logger.LogErrorMessage error */ 2:
+                    message.message = {
+                        oneofKind: "error",
+                        error: LogErrorMessage.internalBinaryRead(reader, reader.uint32(), options, (message.message as any).error)
+                    };
+                    break;
+                case /* devvit.remote_logger.KeepAliveMessage keepalive */ 3:
+                    message.message = {
+                        oneofKind: "keepalive",
+                        keepalive: KeepAliveMessage.internalBinaryRead(reader, reader.uint32(), options, (message.message as any).keepalive)
+                    };
+                    break;
+                case /* devvit.plugin.logger.LogEventMessage event */ 4:
+                    message.message = {
+                        oneofKind: "event",
+                        event: LogEventMessage.internalBinaryRead(reader, reader.uint32(), options, (message.message as any).event)
+                    };
+                    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: RemoteLogMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.plugin.logger.LogMessage log = 1; */
+        if (message.message.oneofKind === "log")
+            LogMessage.internalBinaryWrite(message.message.log, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.plugin.logger.LogErrorMessage error = 2; */
+        if (message.message.oneofKind === "error")
+            LogErrorMessage.internalBinaryWrite(message.message.error, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.remote_logger.KeepAliveMessage keepalive = 3; */
+        if (message.message.oneofKind === "keepalive")
+            KeepAliveMessage.internalBinaryWrite(message.message.keepalive, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.plugin.logger.LogEventMessage event = 4; */
+        if (message.message.oneofKind === "event")
+            LogEventMessage.internalBinaryWrite(message.message.event, writer.tag(4, 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.remote_logger.RemoteLogMessage
+ */
+export const RemoteLogMessage = new RemoteLogMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoteLogInstallationFilter$Type extends MessageType<RemoteLogInstallationFilter> {
+    constructor() {
+        super("devvit.remote_logger.RemoteLogInstallationFilter", [
+            { no: 1, name: "installation_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<RemoteLogInstallationFilter>): RemoteLogInstallationFilter {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.installationId = "";
+        if (value !== undefined)
+            reflectionMergePartial<RemoteLogInstallationFilter>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoteLogInstallationFilter): RemoteLogInstallationFilter {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string installation_id */ 1:
+                    message.installationId = 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: RemoteLogInstallationFilter, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string installation_id = 1; */
+        if (message.installationId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.installationId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.remote_logger.RemoteLogInstallationFilter
+ */
+export const RemoteLogInstallationFilter = new RemoteLogInstallationFilter$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoteLogSubredditAppNameFilter$Type extends MessageType<RemoteLogSubredditAppNameFilter> {
+    constructor() {
+        super("devvit.remote_logger.RemoteLogSubredditAppNameFilter", [
+            { no: 2, name: "subreddit", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "app_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<RemoteLogSubredditAppNameFilter>): RemoteLogSubredditAppNameFilter {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.subreddit = "";
+        message.appName = "";
+        if (value !== undefined)
+            reflectionMergePartial<RemoteLogSubredditAppNameFilter>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoteLogSubredditAppNameFilter): RemoteLogSubredditAppNameFilter {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string subreddit */ 2:
+                    message.subreddit = reader.string();
+                    break;
+                case /* string app_name */ 3:
+                    message.appName = 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: RemoteLogSubredditAppNameFilter, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string subreddit = 2; */
+        if (message.subreddit !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.subreddit);
+        /* string app_name = 3; */
+        if (message.appName !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.appName);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.remote_logger.RemoteLogSubredditAppNameFilter
+ */
+export const RemoteLogSubredditAppNameFilter = new RemoteLogSubredditAppNameFilter$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RemoteLogQuery$Type extends MessageType<RemoteLogQuery> {
+    constructor() {
+        super("devvit.remote_logger.RemoteLogQuery", [
+            { no: 1, name: "installation", kind: "message", oneof: "filter", T: () => RemoteLogInstallationFilter },
+            { no: 2, name: "subreddit_app_name", kind: "message", oneof: "filter", T: () => RemoteLogSubredditAppNameFilter },
+            { no: 3, name: "type", kind: "enum", T: () => ["devvit.remote_logger.RemoteLogType", RemoteLogType] },
+            { no: 4, name: "since", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value?: PartialMessage<RemoteLogQuery>): RemoteLogQuery {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.filter = { oneofKind: undefined };
+        message.type = 0;
+        if (value !== undefined)
+            reflectionMergePartial<RemoteLogQuery>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RemoteLogQuery): RemoteLogQuery {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.remote_logger.RemoteLogInstallationFilter installation */ 1:
+                    message.filter = {
+                        oneofKind: "installation",
+                        installation: RemoteLogInstallationFilter.internalBinaryRead(reader, reader.uint32(), options, (message.filter as any).installation)
+                    };
+                    break;
+                case /* devvit.remote_logger.RemoteLogSubredditAppNameFilter subreddit_app_name */ 2:
+                    message.filter = {
+                        oneofKind: "subredditAppName",
+                        subredditAppName: RemoteLogSubredditAppNameFilter.internalBinaryRead(reader, reader.uint32(), options, (message.filter as any).subredditAppName)
+                    };
+                    break;
+                case /* devvit.remote_logger.RemoteLogType type */ 3:
+                    message.type = reader.int32();
+                    break;
+                case /* google.protobuf.Timestamp since */ 4:
+                    message.since = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.since);
+                    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: RemoteLogQuery, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.remote_logger.RemoteLogInstallationFilter installation = 1; */
+        if (message.filter.oneofKind === "installation")
+            RemoteLogInstallationFilter.internalBinaryWrite(message.filter.installation, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.remote_logger.RemoteLogSubredditAppNameFilter subreddit_app_name = 2; */
+        if (message.filter.oneofKind === "subredditAppName")
+            RemoteLogSubredditAppNameFilter.internalBinaryWrite(message.filter.subredditAppName, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.remote_logger.RemoteLogType type = 3; */
+        if (message.type !== 0)
+            writer.tag(3, WireType.Varint).int32(message.type);
+        /* google.protobuf.Timestamp since = 4; */
+        if (message.since)
+            Timestamp.internalBinaryWrite(message.since, writer.tag(4, 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.remote_logger.RemoteLogQuery
+ */
+export const RemoteLogQuery = new RemoteLogQuery$Type();
+/**
+ * @generated ServiceType for protobuf service devvit.remote_logger.RemoteLogPublisher
+ */
+export const RemoteLogPublisher = new ServiceType("devvit.remote_logger.RemoteLogPublisher", [
+    { name: "Put", options: {}, I: RemoteLogMessage, O: RemoteLogPutResponse },
+    { name: "PutAll", options: {}, I: RemoteLogMessages, O: RemoteLogPutResponse }
+]);
+/**
+ * @generated ServiceType for protobuf service devvit.remote_logger.RemoteLogConsumer
+ */
+export const RemoteLogConsumer = new ServiceType("devvit.remote_logger.RemoteLogConsumer", [
+    { name: "Tail", serverStreaming: true, options: {}, I: RemoteLogQuery, O: RemoteLogMessage }
+]);

package/schema/.snootobuf/output/devenv_ts_files/devvit/runtime/actor/bootstrap.client.ts

@@ -0,0 +1,56 @@
+// @generated by protobuf-ts 2.9.3
+// @generated from protobuf file "devvit/runtime/actor/bootstrap.proto" (package "devvit.runtime.actor", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { BootstrapActor } from "./bootstrap";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { Empty } from "../../../google/protobuf/empty";
+import type { LinkedBundle } from "../bundle";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * Bootstraper used to load an actual Actor into the Worker
+ *
+ * @generated from protobuf service devvit.runtime.actor.BootstrapActor
+ */
+export interface IBootstrapActorClient {
+    /**
+     * Loads an Actor into the Worker and binds its service to a URL
+     *
+     * @generated from protobuf rpc: LoadActor(devvit.runtime.LinkedBundle) returns (google.protobuf.Empty);
+     */
+    loadActor(input: LinkedBundle, options?: RpcOptions): UnaryCall<LinkedBundle, Empty>;
+    /**
+     * @generated from protobuf rpc: IsResponding(google.protobuf.Empty) returns (google.protobuf.Empty);
+     */
+    isResponding(input: Empty, options?: RpcOptions): UnaryCall<Empty, Empty>;
+}
+/**
+ * Bootstraper used to load an actual Actor into the Worker
+ *
+ * @generated from protobuf service devvit.runtime.actor.BootstrapActor
+ */
+export class BootstrapActorClient implements IBootstrapActorClient, ServiceInfo {
+    typeName = BootstrapActor.typeName;
+    methods = BootstrapActor.methods;
+    options = BootstrapActor.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * Loads an Actor into the Worker and binds its service to a URL
+     *
+     * @generated from protobuf rpc: LoadActor(devvit.runtime.LinkedBundle) returns (google.protobuf.Empty);
+     */
+    loadActor(input: LinkedBundle, options?: RpcOptions): UnaryCall<LinkedBundle, Empty> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<LinkedBundle, Empty>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: IsResponding(google.protobuf.Empty) returns (google.protobuf.Empty);
+     */
+    isResponding(input: Empty, options?: RpcOptions): UnaryCall<Empty, Empty> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<Empty, Empty>("unary", this._transport, method, opt, input);
+    }
+}