@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/ui/effects/v1alpha/create_order.ts

@@ -0,0 +1,217 @@
+// @generated by protobuf-ts 2.9.3
+// @generated from protobuf file "devvit/ui/effects/v1alpha/create_order.proto" (package "devvit.ui.effects.v1alpha", 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 { MessageType } from "@protobuf-ts/runtime";
+/**
+ * Emitted by an app to request a purchase flow by the client
+ *
+ * @generated from protobuf message devvit.ui.effects.v1alpha.CreateOrderEffect
+ */
+export interface CreateOrderEffect {
+    /**
+     * ID of this effect to route the OrderResultEvent to the correct handler
+     *
+     * @generated from protobuf field: string id = 1;
+     */
+    id: string;
+    /**
+     * List of product SKUs the user intends to purchase
+     *
+     * @generated from protobuf field: repeated string skus = 2;
+     */
+    skus: string[];
+    /**
+     * Optional metadata map
+     *
+     * @generated from protobuf field: map<string, string> metadata = 3;
+     */
+    metadata: {
+        [key: string]: string;
+    };
+}
+/**
+ * Sent to the app after the purchase attempt has concluded
+ *
+ * @generated from protobuf message devvit.ui.effects.v1alpha.OrderResultEvent
+ */
+export interface OrderResultEvent {
+    /**
+     * Status flag
+     *
+     * @generated from protobuf field: bool success = 1;
+     */
+    success: boolean;
+    /**
+     * If success is false, why?
+     *
+     * @generated from protobuf field: optional string error_message = 2;
+     */
+    errorMessage?: string;
+    /**
+     * If success is true, the order ID for the app to use to verify the purchase
+     *
+     * @generated from protobuf field: optional string order_id = 3;
+     */
+    orderId?: string;
+    /**
+     * The original request
+     *
+     * @generated from protobuf field: devvit.ui.effects.v1alpha.CreateOrderEffect order = 4;
+     */
+    order?: CreateOrderEffect;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class CreateOrderEffect$Type extends MessageType<CreateOrderEffect> {
+    constructor() {
+        super("devvit.ui.effects.v1alpha.CreateOrderEffect", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "skus", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "metadata", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } }
+        ]);
+    }
+    create(value?: PartialMessage<CreateOrderEffect>): CreateOrderEffect {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = "";
+        message.skus = [];
+        message.metadata = {};
+        if (value !== undefined)
+            reflectionMergePartial<CreateOrderEffect>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CreateOrderEffect): CreateOrderEffect {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* repeated string skus */ 2:
+                    message.skus.push(reader.string());
+                    break;
+                case /* map<string, string> metadata */ 3:
+                    this.binaryReadMap3(message.metadata, 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: CreateOrderEffect["metadata"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof CreateOrderEffect["metadata"] | undefined, val: CreateOrderEffect["metadata"][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.ui.effects.v1alpha.CreateOrderEffect.metadata");
+            }
+        }
+        map[key ?? ""] = val ?? "";
+    }
+    internalBinaryWrite(message: CreateOrderEffect, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* repeated string skus = 2; */
+        for (let i = 0; i < message.skus.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.skus[i]);
+        /* map<string, string> metadata = 3; */
+        for (let k of globalThis.Object.keys(message.metadata))
+            writer.tag(3, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.metadata[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.ui.effects.v1alpha.CreateOrderEffect
+ */
+export const CreateOrderEffect = new CreateOrderEffect$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderResultEvent$Type extends MessageType<OrderResultEvent> {
+    constructor() {
+        super("devvit.ui.effects.v1alpha.OrderResultEvent", [
+            { no: 1, name: "success", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "error_message", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "order_id", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "order", kind: "message", T: () => CreateOrderEffect }
+        ]);
+    }
+    create(value?: PartialMessage<OrderResultEvent>): OrderResultEvent {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.success = false;
+        if (value !== undefined)
+            reflectionMergePartial<OrderResultEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderResultEvent): OrderResultEvent {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool success */ 1:
+                    message.success = reader.bool();
+                    break;
+                case /* optional string error_message */ 2:
+                    message.errorMessage = reader.string();
+                    break;
+                case /* optional string order_id */ 3:
+                    message.orderId = reader.string();
+                    break;
+                case /* devvit.ui.effects.v1alpha.CreateOrderEffect order */ 4:
+                    message.order = CreateOrderEffect.internalBinaryRead(reader, reader.uint32(), options, message.order);
+                    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: OrderResultEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* bool success = 1; */
+        if (message.success !== false)
+            writer.tag(1, WireType.Varint).bool(message.success);
+        /* optional string error_message = 2; */
+        if (message.errorMessage !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.errorMessage);
+        /* optional string order_id = 3; */
+        if (message.orderId !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.orderId);
+        /* devvit.ui.effects.v1alpha.CreateOrderEffect order = 4; */
+        if (message.order)
+            CreateOrderEffect.internalBinaryWrite(message.order, 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.ui.effects.v1alpha.OrderResultEvent
+ */
+export const OrderResultEvent = new OrderResultEvent$Type();

package/schema/.snootobuf/output/devenv_ts_files/devvit/ui/effects/v1alpha/effect.ts

@@ -0,0 +1,266 @@
+// @generated by protobuf-ts 2.9.3
+// @generated from protobuf file "devvit/ui/effects/v1alpha/effect.proto" (package "devvit.ui.effects.v1alpha", 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 { MessageType } from "@protobuf-ts/runtime";
+import { CreateOrderEffect } from "./create_order";
+import { SetIntervalsEffect } from "./interval";
+import { NavigateToUrlEffect } from "./navigate_to_url";
+import { ShowToastEffect } from "./show_toast";
+import { ShowFormEffect } from "./show_form";
+import { ReloadPartEffect } from "./reload_part";
+import { RerenderEffect } from "./rerender_ui";
+import { RealtimeSubscriptionsEffect } from "./realtime_subscriptions";
+/**
+ * @generated from protobuf message devvit.ui.effects.v1alpha.Effect
+ */
+export interface Effect {
+    /**
+     * @generated from protobuf oneof: effect_type
+     */
+    effectType: {
+        oneofKind: "realtimeSubscriptions";
+        /**
+         * @generated from protobuf field: devvit.ui.effects.v1alpha.RealtimeSubscriptionsEffect realtime_subscriptions = 1;
+         */
+        realtimeSubscriptions: RealtimeSubscriptionsEffect;
+    } | {
+        oneofKind: "rerenderUi";
+        /**
+         * @generated from protobuf field: devvit.ui.effects.v1alpha.RerenderEffect rerender_ui = 2;
+         */
+        rerenderUi: RerenderEffect;
+    } | {
+        oneofKind: "reloadPart";
+        /**
+         * @generated from protobuf field: devvit.ui.effects.v1alpha.ReloadPartEffect reload_part = 3;
+         */
+        reloadPart: ReloadPartEffect;
+    } | {
+        oneofKind: "showForm";
+        /**
+         * @generated from protobuf field: devvit.ui.effects.v1alpha.ShowFormEffect show_form = 4;
+         */
+        showForm: ShowFormEffect;
+    } | {
+        oneofKind: "showToast";
+        /**
+         * @generated from protobuf field: devvit.ui.effects.v1alpha.ShowToastEffect show_toast = 5;
+         */
+        showToast: ShowToastEffect;
+    } | {
+        oneofKind: "navigateToUrl";
+        /**
+         * @generated from protobuf field: devvit.ui.effects.v1alpha.NavigateToUrlEffect navigate_to_url = 6;
+         */
+        navigateToUrl: NavigateToUrlEffect;
+    } | {
+        oneofKind: "interval";
+        /**
+         * @generated from protobuf field: devvit.ui.effects.v1alpha.SetIntervalsEffect interval = 9;
+         */
+        interval: SetIntervalsEffect;
+    } | {
+        oneofKind: "createOrder";
+        /**
+         * @generated from protobuf field: devvit.ui.effects.v1alpha.CreateOrderEffect create_order = 10;
+         */
+        createOrder: CreateOrderEffect;
+    } | {
+        oneofKind: undefined;
+    };
+    /**
+     * TODO: remove this field once all clients are updated.  Redundant with effect_type
+     *
+     * @generated from protobuf field: devvit.ui.effects.v1alpha.EffectType type = 7;
+     */
+    type: EffectType;
+}
+/**
+ * @generated from protobuf enum devvit.ui.effects.v1alpha.EffectType
+ */
+export enum EffectType {
+    /**
+     * Notify client to synchronize its realtime subscriptions
+     *
+     * @generated from protobuf enum value: EFFECT_REALTIME_SUB = 0;
+     */
+    EFFECT_REALTIME_SUB = 0,
+    /**
+     * Trigger a re-render for apps that have visible UI
+     *
+     * @generated from protobuf enum value: EFFECT_RERENDER_UI = 1;
+     */
+    EFFECT_RERENDER_UI = 1,
+    /**
+     * Notify the client that parts of a subreddit, post, or comment should be reloaded
+     *
+     * @generated from protobuf enum value: EFFECT_RELOAD_PART = 2;
+     */
+    EFFECT_RELOAD_PART = 2,
+    /**
+     * Display a user input form
+     *
+     * @generated from protobuf enum value: EFFECT_SHOW_FORM = 3;
+     */
+    EFFECT_SHOW_FORM = 3,
+    /**
+     * Display a transient toast message
+     *
+     * @generated from protobuf enum value: EFFECT_SHOW_TOAST = 4;
+     */
+    EFFECT_SHOW_TOAST = 4,
+    /**
+     * Notify the client to navigate to a URL
+     *
+     * @generated from protobuf enum value: EFFECT_NAVIGATE_TO_URL = 5;
+     */
+    EFFECT_NAVIGATE_TO_URL = 5,
+    /**
+     * This updates the list of active timers.
+     *
+     * @generated from protobuf enum value: EFFECT_SET_INTERVALS = 7;
+     */
+    EFFECT_SET_INTERVALS = 7,
+    /**
+     * This starts a purchase flow
+     *
+     * @generated from protobuf enum value: EFFECT_CREATE_ORDER = 8;
+     */
+    EFFECT_CREATE_ORDER = 8
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Effect$Type extends MessageType<Effect> {
+    constructor() {
+        super("devvit.ui.effects.v1alpha.Effect", [
+            { no: 1, name: "realtime_subscriptions", kind: "message", oneof: "effectType", T: () => RealtimeSubscriptionsEffect },
+            { no: 2, name: "rerender_ui", kind: "message", oneof: "effectType", T: () => RerenderEffect },
+            { no: 3, name: "reload_part", kind: "message", oneof: "effectType", T: () => ReloadPartEffect },
+            { no: 4, name: "show_form", kind: "message", oneof: "effectType", T: () => ShowFormEffect },
+            { no: 5, name: "show_toast", kind: "message", oneof: "effectType", T: () => ShowToastEffect },
+            { no: 6, name: "navigate_to_url", kind: "message", oneof: "effectType", T: () => NavigateToUrlEffect },
+            { no: 9, name: "interval", kind: "message", oneof: "effectType", T: () => SetIntervalsEffect },
+            { no: 10, name: "create_order", kind: "message", oneof: "effectType", T: () => CreateOrderEffect },
+            { no: 7, name: "type", kind: "enum", T: () => ["devvit.ui.effects.v1alpha.EffectType", EffectType] }
+        ]);
+    }
+    create(value?: PartialMessage<Effect>): Effect {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.effectType = { oneofKind: undefined };
+        message.type = 0;
+        if (value !== undefined)
+            reflectionMergePartial<Effect>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Effect): Effect {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* devvit.ui.effects.v1alpha.RealtimeSubscriptionsEffect realtime_subscriptions */ 1:
+                    message.effectType = {
+                        oneofKind: "realtimeSubscriptions",
+                        realtimeSubscriptions: RealtimeSubscriptionsEffect.internalBinaryRead(reader, reader.uint32(), options, (message.effectType as any).realtimeSubscriptions)
+                    };
+                    break;
+                case /* devvit.ui.effects.v1alpha.RerenderEffect rerender_ui */ 2:
+                    message.effectType = {
+                        oneofKind: "rerenderUi",
+                        rerenderUi: RerenderEffect.internalBinaryRead(reader, reader.uint32(), options, (message.effectType as any).rerenderUi)
+                    };
+                    break;
+                case /* devvit.ui.effects.v1alpha.ReloadPartEffect reload_part */ 3:
+                    message.effectType = {
+                        oneofKind: "reloadPart",
+                        reloadPart: ReloadPartEffect.internalBinaryRead(reader, reader.uint32(), options, (message.effectType as any).reloadPart)
+                    };
+                    break;
+                case /* devvit.ui.effects.v1alpha.ShowFormEffect show_form */ 4:
+                    message.effectType = {
+                        oneofKind: "showForm",
+                        showForm: ShowFormEffect.internalBinaryRead(reader, reader.uint32(), options, (message.effectType as any).showForm)
+                    };
+                    break;
+                case /* devvit.ui.effects.v1alpha.ShowToastEffect show_toast */ 5:
+                    message.effectType = {
+                        oneofKind: "showToast",
+                        showToast: ShowToastEffect.internalBinaryRead(reader, reader.uint32(), options, (message.effectType as any).showToast)
+                    };
+                    break;
+                case /* devvit.ui.effects.v1alpha.NavigateToUrlEffect navigate_to_url */ 6:
+                    message.effectType = {
+                        oneofKind: "navigateToUrl",
+                        navigateToUrl: NavigateToUrlEffect.internalBinaryRead(reader, reader.uint32(), options, (message.effectType as any).navigateToUrl)
+                    };
+                    break;
+                case /* devvit.ui.effects.v1alpha.SetIntervalsEffect interval */ 9:
+                    message.effectType = {
+                        oneofKind: "interval",
+                        interval: SetIntervalsEffect.internalBinaryRead(reader, reader.uint32(), options, (message.effectType as any).interval)
+                    };
+                    break;
+                case /* devvit.ui.effects.v1alpha.CreateOrderEffect create_order */ 10:
+                    message.effectType = {
+                        oneofKind: "createOrder",
+                        createOrder: CreateOrderEffect.internalBinaryRead(reader, reader.uint32(), options, (message.effectType as any).createOrder)
+                    };
+                    break;
+                case /* devvit.ui.effects.v1alpha.EffectType type */ 7:
+                    message.type = reader.int32();
+                    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: Effect, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* devvit.ui.effects.v1alpha.RealtimeSubscriptionsEffect realtime_subscriptions = 1; */
+        if (message.effectType.oneofKind === "realtimeSubscriptions")
+            RealtimeSubscriptionsEffect.internalBinaryWrite(message.effectType.realtimeSubscriptions, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.ui.effects.v1alpha.RerenderEffect rerender_ui = 2; */
+        if (message.effectType.oneofKind === "rerenderUi")
+            RerenderEffect.internalBinaryWrite(message.effectType.rerenderUi, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.ui.effects.v1alpha.ReloadPartEffect reload_part = 3; */
+        if (message.effectType.oneofKind === "reloadPart")
+            ReloadPartEffect.internalBinaryWrite(message.effectType.reloadPart, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.ui.effects.v1alpha.ShowFormEffect show_form = 4; */
+        if (message.effectType.oneofKind === "showForm")
+            ShowFormEffect.internalBinaryWrite(message.effectType.showForm, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.ui.effects.v1alpha.ShowToastEffect show_toast = 5; */
+        if (message.effectType.oneofKind === "showToast")
+            ShowToastEffect.internalBinaryWrite(message.effectType.showToast, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.ui.effects.v1alpha.NavigateToUrlEffect navigate_to_url = 6; */
+        if (message.effectType.oneofKind === "navigateToUrl")
+            NavigateToUrlEffect.internalBinaryWrite(message.effectType.navigateToUrl, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.ui.effects.v1alpha.SetIntervalsEffect interval = 9; */
+        if (message.effectType.oneofKind === "interval")
+            SetIntervalsEffect.internalBinaryWrite(message.effectType.interval, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.ui.effects.v1alpha.CreateOrderEffect create_order = 10; */
+        if (message.effectType.oneofKind === "createOrder")
+            CreateOrderEffect.internalBinaryWrite(message.effectType.createOrder, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* devvit.ui.effects.v1alpha.EffectType type = 7; */
+        if (message.type !== 0)
+            writer.tag(7, WireType.Varint).int32(message.type);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message devvit.ui.effects.v1alpha.Effect
+ */
+export const Effect = new Effect$Type();

package/schema/.snootobuf/output/devenv_ts_files/devvit/ui/effects/v1alpha/interval.ts

@@ -0,0 +1,169 @@
+// @generated by protobuf-ts 2.9.3
+// @generated from protobuf file "devvit/ui/effects/v1alpha/interval.proto" (package "devvit.ui.effects.v1alpha", 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 { MessageType } from "@protobuf-ts/runtime";
+import { BoolValue } from "../../../../google/protobuf/wrappers";
+import { Duration } from "../../../../google/protobuf/duration";
+/**
+ * *
+ * This is the list of active timers.  We could choose to have an effect per timer, but
+ * following realtime's lead, we send the whole list.
+ *
+ * This implies that if the timer disappears from the map, you should cancel it.
+ *
+ * @generated from protobuf message devvit.ui.effects.v1alpha.SetIntervalsEffect
+ */
+export interface SetIntervalsEffect {
+    /**
+     * hook_id => interval map
+     *
+     * @generated from protobuf field: map<string, devvit.ui.effects.v1alpha.IntervalDetails> intervals = 1;
+     */
+    intervals: {
+        [key: string]: IntervalDetails;
+    };
+}
+/**
+ * @generated from protobuf message devvit.ui.effects.v1alpha.IntervalDetails
+ */
+export interface IntervalDetails {
+    /**
+     * @generated from protobuf field: google.protobuf.Duration duration = 1;
+     */
+    duration?: Duration;
+    /**
+     * *
+     * Distinguishes between synchronous and asynchronous events.
+     *
+     * @generated from protobuf field: google.protobuf.BoolValue async = 3;
+     */
+    async?: BoolValue;
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class SetIntervalsEffect$Type extends MessageType<SetIntervalsEffect> {
+    constructor() {
+        super("devvit.ui.effects.v1alpha.SetIntervalsEffect", [
+            { no: 1, name: "intervals", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => IntervalDetails } }
+        ]);
+    }
+    create(value?: PartialMessage<SetIntervalsEffect>): SetIntervalsEffect {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.intervals = {};
+        if (value !== undefined)
+            reflectionMergePartial<SetIntervalsEffect>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SetIntervalsEffect): SetIntervalsEffect {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* map<string, devvit.ui.effects.v1alpha.IntervalDetails> intervals */ 1:
+                    this.binaryReadMap1(message.intervals, 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 binaryReadMap1(map: SetIntervalsEffect["intervals"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof SetIntervalsEffect["intervals"] | undefined, val: SetIntervalsEffect["intervals"][any] | undefined;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = IntervalDetails.internalBinaryRead(reader, reader.uint32(), options);
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for field devvit.ui.effects.v1alpha.SetIntervalsEffect.intervals");
+            }
+        }
+        map[key ?? ""] = val ?? IntervalDetails.create();
+    }
+    internalBinaryWrite(message: SetIntervalsEffect, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* map<string, devvit.ui.effects.v1alpha.IntervalDetails> intervals = 1; */
+        for (let k of globalThis.Object.keys(message.intervals)) {
+            writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+            writer.tag(2, WireType.LengthDelimited).fork();
+            IntervalDetails.internalBinaryWrite(message.intervals[k], writer, options);
+            writer.join().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.ui.effects.v1alpha.SetIntervalsEffect
+ */
+export const SetIntervalsEffect = new SetIntervalsEffect$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class IntervalDetails$Type extends MessageType<IntervalDetails> {
+    constructor() {
+        super("devvit.ui.effects.v1alpha.IntervalDetails", [
+            { no: 1, name: "duration", kind: "message", T: () => Duration },
+            { no: 3, name: "async", kind: "message", T: () => BoolValue }
+        ]);
+    }
+    create(value?: PartialMessage<IntervalDetails>): IntervalDetails {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<IntervalDetails>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: IntervalDetails): IntervalDetails {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* google.protobuf.Duration duration */ 1:
+                    message.duration = Duration.internalBinaryRead(reader, reader.uint32(), options, message.duration);
+                    break;
+                case /* google.protobuf.BoolValue async */ 3:
+                    message.async = BoolValue.internalBinaryRead(reader, reader.uint32(), options, message.async);
+                    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: IntervalDetails, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* google.protobuf.Duration duration = 1; */
+        if (message.duration)
+            Duration.internalBinaryWrite(message.duration, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.BoolValue async = 3; */
+        if (message.async)
+            BoolValue.internalBinaryWrite(message.async, writer.tag(3, 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.ui.effects.v1alpha.IntervalDetails
+ */
+export const IntervalDetails = new IntervalDetails$Type();