@miradorlabs/web-grpc 3.32.0 → 3.33.0

package/proto/gateway/web/v1/ai_gateway.ts

@@ -448,6 +448,64 @@ export function aITokenActivityDimensionToJSON(object: AITokenActivityDimension)
   }
 }
 
+/** AISpendForecastDimension mirrors telemetry.api.v1.AISpendForecastDimension. */
+export enum AISpendForecastDimension {
+  AI_SPEND_FORECAST_DIMENSION_UNSPECIFIED = 0,
+  AI_SPEND_FORECAST_DIMENSION_MODEL = 1,
+  AI_SPEND_FORECAST_DIMENSION_PROVIDER = 2,
+  AI_SPEND_FORECAST_DIMENSION_SOURCE_SYSTEM = 3,
+  AI_SPEND_FORECAST_DIMENSION_USER = 4,
+  AI_SPEND_FORECAST_DIMENSION_API_KEY = 5,
+  UNRECOGNIZED = -1,
+}
+
+export function aISpendForecastDimensionFromJSON(object: any): AISpendForecastDimension {
+  switch (object) {
+    case 0:
+    case "AI_SPEND_FORECAST_DIMENSION_UNSPECIFIED":
+      return AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_UNSPECIFIED;
+    case 1:
+    case "AI_SPEND_FORECAST_DIMENSION_MODEL":
+      return AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_MODEL;
+    case 2:
+    case "AI_SPEND_FORECAST_DIMENSION_PROVIDER":
+      return AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_PROVIDER;
+    case 3:
+    case "AI_SPEND_FORECAST_DIMENSION_SOURCE_SYSTEM":
+      return AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_SOURCE_SYSTEM;
+    case 4:
+    case "AI_SPEND_FORECAST_DIMENSION_USER":
+      return AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_USER;
+    case 5:
+    case "AI_SPEND_FORECAST_DIMENSION_API_KEY":
+      return AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_API_KEY;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return AISpendForecastDimension.UNRECOGNIZED;
+  }
+}
+
+export function aISpendForecastDimensionToJSON(object: AISpendForecastDimension): string {
+  switch (object) {
+    case AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_UNSPECIFIED:
+      return "AI_SPEND_FORECAST_DIMENSION_UNSPECIFIED";
+    case AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_MODEL:
+      return "AI_SPEND_FORECAST_DIMENSION_MODEL";
+    case AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_PROVIDER:
+      return "AI_SPEND_FORECAST_DIMENSION_PROVIDER";
+    case AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_SOURCE_SYSTEM:
+      return "AI_SPEND_FORECAST_DIMENSION_SOURCE_SYSTEM";
+    case AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_USER:
+      return "AI_SPEND_FORECAST_DIMENSION_USER";
+    case AISpendForecastDimension.AI_SPEND_FORECAST_DIMENSION_API_KEY:
+      return "AI_SPEND_FORECAST_DIMENSION_API_KEY";
+    case AISpendForecastDimension.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export enum AIResourceDimension {
   AI_RESOURCE_DIMENSION_UNSPECIFIED = 0,
   AI_RESOURCE_DIMENSION_SKILL = 1,
@@ -1591,6 +1649,83 @@ export interface DailyActivityMeasures {
   sessions: number;
 }
 
+export interface SpendForecastRequest {
+  organizationId: string;
+  projectId: string;
+  /** Optional slice; unset forecasts the cost on every funding facility. */
+  filter: SpendForecastFilter | undefined;
+}
+
+/** SpendForecastFilter narrows the cost a forecast counts. An empty list does not filter. */
+export interface SpendForecastFilter {
+  /**
+   * OR within the list. UNKNOWN selects every cost off the three named facilities (observed-unknown, never-stamped
+   * or an unrecognized facility); UNSPECIFIED is rejected.
+   * [API_METERED, PREPAID_CREDITS, UNKNOWN] is the cost not drawn on a subscription facility.
+   */
+  fundingModes: AIFundingMode[];
+}
+
+/**
+ * SpendForecast mirrors telemetry.api.v1.SpendForecast, replaced wholesale each tick. Cost is notional (the
+ * source's reported figure, else tokens x list price), never an invoice: an unpriced call counts 0.
+ */
+export interface SpendForecast {
+  /** first UTC day of the current month, YYYY-MM-DD */
+  periodStart: string;
+  /** last UTC day of the current month */
+  periodEnd: string;
+  /** provisional; its cost so far is in month_to_date_usd */
+  today: string;
+  /**
+   * Earliest UTC day the rollup is authoritative for this project; empty when nothing is materialized. Month
+   * days before it are uncomputed and not in month_to_date_usd.
+   */
+  coverageStart: string;
+  /**
+   * Complete trailing 7-day weeks (0 to 4, newest ending yesterday) the projection replays. 0 means too little
+   * history, and every projection is absent.
+   */
+  historyWeeks: number;
+  total:
+    | SpendForecastMeasures
+    | undefined;
+  /**
+   * One breakdown per AISpendForecastDimension. Each partitions total's month_to_date_usd and
+   * projection.expected_usd exactly; a group's low_usd and high_usd do not sum to total's.
+   */
+  breakdowns: SpendForecastBreakdown[];
+  asOf: Date | undefined;
+}
+
+export interface SpendForecastBreakdown {
+  dimension: AISpendForecastDimension;
+  /** ascending by key */
+  groups: SpendForecastGroup[];
+}
+
+/** An empty key is cost that recorded none. */
+export interface SpendForecastGroup {
+  key: string;
+  measures: SpendForecastMeasures | undefined;
+}
+
+export interface SpendForecastMeasures {
+  monthToDateUsd: number;
+  /** absent when history_weeks is 0 */
+  projection: SpendProjection | undefined;
+}
+
+/**
+ * SpendProjection is the projected month-end total, month to date included: the mean, the quietest and the
+ * busiest of the history weeks replayed weekday by weekday over the rest of the month.
+ */
+export interface SpendProjection {
+  expectedUsd: number;
+  lowUsd: number;
+  highUsd: number;
+}
+
 export interface ActivityRhythmRequest {
   organizationId: string;
   projectId: string;
@@ -11685,28 +11820,25 @@ export const DailyActivityMeasures: MessageFns<DailyActivityMeasures> = {
   },
 };
 
-function createBaseActivityRhythmRequest(): ActivityRhythmRequest {
-  return { organizationId: "", projectId: "", timeWindow: 0, timeZone: "" };
+function createBaseSpendForecastRequest(): SpendForecastRequest {
+  return { organizationId: "", projectId: "", filter: undefined };
 }
 
-export const ActivityRhythmRequest: MessageFns<ActivityRhythmRequest> = {
-  encode(message: ActivityRhythmRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const SpendForecastRequest: MessageFns<SpendForecastRequest> = {
+  encode(message: SpendForecastRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.organizationId !== "") {
       writer.uint32(10).string(message.organizationId);
     }
     if (message.projectId !== "") {
       writer.uint32(18).string(message.projectId);
     }
-    if (message.timeWindow !== 0) {
-      writer.uint32(24).int32(message.timeWindow);
-    }
-    if (message.timeZone !== "") {
-      writer.uint32(34).string(message.timeZone);
+    if (message.filter !== undefined) {
+      SpendForecastFilter.encode(message.filter, writer.uint32(26).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): ActivityRhythmRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): SpendForecastRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -11715,7 +11847,7 @@ export const ActivityRhythmRequest: MessageFns<ActivityRhythmRequest> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseActivityRhythmRequest();
+      const message = createBaseSpendForecastRequest();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -11736,19 +11868,11 @@ export const ActivityRhythmRequest: MessageFns<ActivityRhythmRequest> = {
             continue;
           }
           case 3: {
-            if (tag !== 24) {
-              break;
-            }
-
-            message.timeWindow = reader.int32() as any;
-            continue;
-          }
-          case 4: {
-            if (tag !== 34) {
+            if (tag !== 26) {
               break;
             }
 
-            message.timeZone = reader.string();
+            message.filter = SpendForecastFilter.decode(reader, reader.uint32());
             continue;
           }
         }
@@ -11763,7 +11887,7 @@ export const ActivityRhythmRequest: MessageFns<ActivityRhythmRequest> = {
     }
   },
 
-  fromJSON(object: any): ActivityRhythmRequest {
+  fromJSON(object: any): SpendForecastRequest {
     return {
       organizationId: isSet(object.organizationId)
         ? globalThis.String(object.organizationId)
@@ -11775,20 +11899,11 @@ export const ActivityRhythmRequest: MessageFns<ActivityRhythmRequest> = {
         : isSet(object.project_id)
         ? globalThis.String(object.project_id)
         : "",
-      timeWindow: isSet(object.timeWindow)
-        ? analyticsTimeWindowFromJSON(object.timeWindow)
-        : isSet(object.time_window)
-        ? analyticsTimeWindowFromJSON(object.time_window)
-        : 0,
-      timeZone: isSet(object.timeZone)
-        ? globalThis.String(object.timeZone)
-        : isSet(object.time_zone)
-        ? globalThis.String(object.time_zone)
-        : "",
+      filter: isSet(object.filter) ? SpendForecastFilter.fromJSON(object.filter) : undefined,
     };
   },
 
-  toJSON(message: ActivityRhythmRequest): unknown {
+  toJSON(message: SpendForecastRequest): unknown {
     const obj: any = {};
     if (message.organizationId !== "") {
       obj.organizationId = message.organizationId;
@@ -11796,53 +11911,152 @@ export const ActivityRhythmRequest: MessageFns<ActivityRhythmRequest> = {
     if (message.projectId !== "") {
       obj.projectId = message.projectId;
     }
-    if (message.timeWindow !== 0) {
-      obj.timeWindow = analyticsTimeWindowToJSON(message.timeWindow);
-    }
-    if (message.timeZone !== "") {
-      obj.timeZone = message.timeZone;
+    if (message.filter !== undefined) {
+      obj.filter = SpendForecastFilter.toJSON(message.filter);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<ActivityRhythmRequest>, I>>(base?: I): ActivityRhythmRequest {
-    return ActivityRhythmRequest.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<SpendForecastRequest>, I>>(base?: I): SpendForecastRequest {
+    return SpendForecastRequest.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<ActivityRhythmRequest>, I>>(object: I): ActivityRhythmRequest {
-    const message = createBaseActivityRhythmRequest();
+  fromPartial<I extends Exact<DeepPartial<SpendForecastRequest>, I>>(object: I): SpendForecastRequest {
+    const message = createBaseSpendForecastRequest();
     message.organizationId = object.organizationId ?? "";
     message.projectId = object.projectId ?? "";
-    message.timeWindow = object.timeWindow ?? 0;
-    message.timeZone = object.timeZone ?? "";
+    message.filter = (object.filter !== undefined && object.filter !== null)
+      ? SpendForecastFilter.fromPartial(object.filter)
+      : undefined;
     return message;
   },
 };
 
-function createBaseActivityRhythm(): ActivityRhythm {
-  return { buckets: [], windowStart: undefined, windowEnd: undefined, asOf: undefined, timeZone: "" };
+function createBaseSpendForecastFilter(): SpendForecastFilter {
+  return { fundingModes: [] };
 }
 
-export const ActivityRhythm: MessageFns<ActivityRhythm> = {
-  encode(message: ActivityRhythm, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    for (const v of message.buckets) {
-      ActivityRhythmBucket.encode(v!, writer.uint32(10).fork()).join();
+export const SpendForecastFilter: MessageFns<SpendForecastFilter> = {
+  encode(message: SpendForecastFilter, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.fundingModes) {
+      writer.uint32(8).int32(v!);
     }
-    if (message.windowStart !== undefined) {
-      Timestamp.encode(toTimestamp(message.windowStart), writer.uint32(18).fork()).join();
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SpendForecastFilter {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
     }
-    if (message.windowEnd !== undefined) {
-      Timestamp.encode(toTimestamp(message.windowEnd), writer.uint32(26).fork()).join();
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseSpendForecastFilter();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag === 8) {
+              message.fundingModes.push(reader.int32() as any);
+
+              continue;
+            }
+
+            if (tag === 10) {
+              const end2 = reader.uint32() + reader.pos;
+              while (reader.pos < end2) {
+                message.fundingModes.push(reader.int32() as any);
+              }
+
+              continue;
+            }
+
+            break;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
     }
-    if (message.asOf !== undefined) {
-      Timestamp.encode(toTimestamp(message.asOf), writer.uint32(34).fork()).join();
+  },
+
+  fromJSON(object: any): SpendForecastFilter {
+    return {
+      fundingModes: globalThis.Array.isArray(object?.fundingModes)
+        ? object.fundingModes.map((e: any) => aIFundingModeFromJSON(e))
+        : globalThis.Array.isArray(object?.funding_modes)
+        ? object.funding_modes.map((e: any) => aIFundingModeFromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: SpendForecastFilter): unknown {
+    const obj: any = {};
+    if (message.fundingModes?.length) {
+      obj.fundingModes = message.fundingModes.map((e) => aIFundingModeToJSON(e));
     }
-    if (message.timeZone !== "") {
-      writer.uint32(42).string(message.timeZone);
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SpendForecastFilter>, I>>(base?: I): SpendForecastFilter {
+    return SpendForecastFilter.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SpendForecastFilter>, I>>(object: I): SpendForecastFilter {
+    const message = createBaseSpendForecastFilter();
+    message.fundingModes = object.fundingModes?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseSpendForecast(): SpendForecast {
+  return {
+    periodStart: "",
+    periodEnd: "",
+    today: "",
+    coverageStart: "",
+    historyWeeks: 0,
+    total: undefined,
+    breakdowns: [],
+    asOf: undefined,
+  };
+}
+
+export const SpendForecast: MessageFns<SpendForecast> = {
+  encode(message: SpendForecast, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.periodStart !== "") {
+      writer.uint32(10).string(message.periodStart);
+    }
+    if (message.periodEnd !== "") {
+      writer.uint32(18).string(message.periodEnd);
+    }
+    if (message.today !== "") {
+      writer.uint32(26).string(message.today);
+    }
+    if (message.coverageStart !== "") {
+      writer.uint32(34).string(message.coverageStart);
+    }
+    if (message.historyWeeks !== 0) {
+      writer.uint32(40).uint32(message.historyWeeks);
+    }
+    if (message.total !== undefined) {
+      SpendForecastMeasures.encode(message.total, writer.uint32(50).fork()).join();
+    }
+    for (const v of message.breakdowns) {
+      SpendForecastBreakdown.encode(v!, writer.uint32(58).fork()).join();
+    }
+    if (message.asOf !== undefined) {
+      Timestamp.encode(toTimestamp(message.asOf), writer.uint32(66).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): ActivityRhythm {
+  decode(input: BinaryReader | Uint8Array, length?: number): SpendForecast {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
     if (previousRecursionDepth >= 100) {
@@ -11851,7 +12065,7 @@ export const ActivityRhythm: MessageFns<ActivityRhythm> = {
     (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
     try {
       const end = length === undefined ? reader.len : reader.pos + length;
-      const message = createBaseActivityRhythm();
+      const message = createBaseSpendForecast();
       while (reader.pos < end) {
         const tag = reader.uint32();
         switch (tag >>> 3) {
@@ -11860,7 +12074,7 @@ export const ActivityRhythm: MessageFns<ActivityRhythm> = {
               break;
             }
 
-            message.buckets.push(ActivityRhythmBucket.decode(reader, reader.uint32()));
+            message.periodStart = reader.string();
             continue;
           }
           case 2: {
@@ -11868,7 +12082,7 @@ export const ActivityRhythm: MessageFns<ActivityRhythm> = {
               break;
             }
 
-            message.windowStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            message.periodEnd = reader.string();
             continue;
           }
           case 3: {
@@ -11876,7 +12090,7 @@ export const ActivityRhythm: MessageFns<ActivityRhythm> = {
               break;
             }
 
-            message.windowEnd = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            message.today = reader.string();
             continue;
           }
           case 4: {
@@ -11884,15 +12098,39 @@ export const ActivityRhythm: MessageFns<ActivityRhythm> = {
               break;
             }
 
-            message.asOf = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            message.coverageStart = reader.string();
             continue;
           }
           case 5: {
-            if (tag !== 42) {
+            if (tag !== 40) {
               break;
             }
 
-            message.timeZone = reader.string();
+            message.historyWeeks = reader.uint32();
+            continue;
+          }
+          case 6: {
+            if (tag !== 50) {
+              break;
+            }
+
+            message.total = SpendForecastMeasures.decode(reader, reader.uint32());
+            continue;
+          }
+          case 7: {
+            if (tag !== 58) {
+              break;
+            }
+
+            message.breakdowns.push(SpendForecastBreakdown.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 8: {
+            if (tag !== 66) {
+              break;
+            }
+
+            message.asOf = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
             continue;
           }
         }
@@ -11907,44 +12145,727 @@ export const ActivityRhythm: MessageFns<ActivityRhythm> = {
     }
   },
 
-  fromJSON(object: any): ActivityRhythm {
+  fromJSON(object: any): SpendForecast {
     return {
-      buckets: globalThis.Array.isArray(object?.buckets)
-        ? object.buckets.map((e: any) => ActivityRhythmBucket.fromJSON(e))
+      periodStart: isSet(object.periodStart)
+        ? globalThis.String(object.periodStart)
+        : isSet(object.period_start)
+        ? globalThis.String(object.period_start)
+        : "",
+      periodEnd: isSet(object.periodEnd)
+        ? globalThis.String(object.periodEnd)
+        : isSet(object.period_end)
+        ? globalThis.String(object.period_end)
+        : "",
+      today: isSet(object.today) ? globalThis.String(object.today) : "",
+      coverageStart: isSet(object.coverageStart)
+        ? globalThis.String(object.coverageStart)
+        : isSet(object.coverage_start)
+        ? globalThis.String(object.coverage_start)
+        : "",
+      historyWeeks: isSet(object.historyWeeks)
+        ? globalThis.Number(object.historyWeeks)
+        : isSet(object.history_weeks)
+        ? globalThis.Number(object.history_weeks)
+        : 0,
+      total: isSet(object.total) ? SpendForecastMeasures.fromJSON(object.total) : undefined,
+      breakdowns: globalThis.Array.isArray(object?.breakdowns)
+        ? object.breakdowns.map((e: any) => SpendForecastBreakdown.fromJSON(e))
         : [],
-      windowStart: isSet(object.windowStart)
-        ? fromJsonTimestamp(object.windowStart)
-        : isSet(object.window_start)
-        ? fromJsonTimestamp(object.window_start)
-        : undefined,
-      windowEnd: isSet(object.windowEnd)
-        ? fromJsonTimestamp(object.windowEnd)
-        : isSet(object.window_end)
-        ? fromJsonTimestamp(object.window_end)
-        : undefined,
       asOf: isSet(object.asOf)
         ? fromJsonTimestamp(object.asOf)
         : isSet(object.as_of)
         ? fromJsonTimestamp(object.as_of)
         : undefined,
-      timeZone: isSet(object.timeZone)
-        ? globalThis.String(object.timeZone)
-        : isSet(object.time_zone)
-        ? globalThis.String(object.time_zone)
-        : "",
     };
   },
 
-  toJSON(message: ActivityRhythm): unknown {
+  toJSON(message: SpendForecast): unknown {
     const obj: any = {};
-    if (message.buckets?.length) {
-      obj.buckets = message.buckets.map((e) => ActivityRhythmBucket.toJSON(e));
+    if (message.periodStart !== "") {
+      obj.periodStart = message.periodStart;
     }
-    if (message.windowStart !== undefined) {
-      obj.windowStart = message.windowStart.toISOString();
+    if (message.periodEnd !== "") {
+      obj.periodEnd = message.periodEnd;
     }
-    if (message.windowEnd !== undefined) {
-      obj.windowEnd = message.windowEnd.toISOString();
+    if (message.today !== "") {
+      obj.today = message.today;
+    }
+    if (message.coverageStart !== "") {
+      obj.coverageStart = message.coverageStart;
+    }
+    if (message.historyWeeks !== 0) {
+      obj.historyWeeks = Math.round(message.historyWeeks);
+    }
+    if (message.total !== undefined) {
+      obj.total = SpendForecastMeasures.toJSON(message.total);
+    }
+    if (message.breakdowns?.length) {
+      obj.breakdowns = message.breakdowns.map((e) => SpendForecastBreakdown.toJSON(e));
+    }
+    if (message.asOf !== undefined) {
+      obj.asOf = message.asOf.toISOString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SpendForecast>, I>>(base?: I): SpendForecast {
+    return SpendForecast.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SpendForecast>, I>>(object: I): SpendForecast {
+    const message = createBaseSpendForecast();
+    message.periodStart = object.periodStart ?? "";
+    message.periodEnd = object.periodEnd ?? "";
+    message.today = object.today ?? "";
+    message.coverageStart = object.coverageStart ?? "";
+    message.historyWeeks = object.historyWeeks ?? 0;
+    message.total = (object.total !== undefined && object.total !== null)
+      ? SpendForecastMeasures.fromPartial(object.total)
+      : undefined;
+    message.breakdowns = object.breakdowns?.map((e) => SpendForecastBreakdown.fromPartial(e)) || [];
+    message.asOf = object.asOf ?? undefined;
+    return message;
+  },
+};
+
+function createBaseSpendForecastBreakdown(): SpendForecastBreakdown {
+  return { dimension: 0, groups: [] };
+}
+
+export const SpendForecastBreakdown: MessageFns<SpendForecastBreakdown> = {
+  encode(message: SpendForecastBreakdown, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.dimension !== 0) {
+      writer.uint32(8).int32(message.dimension);
+    }
+    for (const v of message.groups) {
+      SpendForecastGroup.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SpendForecastBreakdown {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseSpendForecastBreakdown();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 8) {
+              break;
+            }
+
+            message.dimension = reader.int32() as any;
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.groups.push(SpendForecastGroup.decode(reader, reader.uint32()));
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): SpendForecastBreakdown {
+    return {
+      dimension: isSet(object.dimension) ? aISpendForecastDimensionFromJSON(object.dimension) : 0,
+      groups: globalThis.Array.isArray(object?.groups)
+        ? object.groups.map((e: any) => SpendForecastGroup.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: SpendForecastBreakdown): unknown {
+    const obj: any = {};
+    if (message.dimension !== 0) {
+      obj.dimension = aISpendForecastDimensionToJSON(message.dimension);
+    }
+    if (message.groups?.length) {
+      obj.groups = message.groups.map((e) => SpendForecastGroup.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SpendForecastBreakdown>, I>>(base?: I): SpendForecastBreakdown {
+    return SpendForecastBreakdown.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SpendForecastBreakdown>, I>>(object: I): SpendForecastBreakdown {
+    const message = createBaseSpendForecastBreakdown();
+    message.dimension = object.dimension ?? 0;
+    message.groups = object.groups?.map((e) => SpendForecastGroup.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSpendForecastGroup(): SpendForecastGroup {
+  return { key: "", measures: undefined };
+}
+
+export const SpendForecastGroup: MessageFns<SpendForecastGroup> = {
+  encode(message: SpendForecastGroup, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.measures !== undefined) {
+      SpendForecastMeasures.encode(message.measures, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SpendForecastGroup {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseSpendForecastGroup();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.key = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.measures = SpendForecastMeasures.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): SpendForecastGroup {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      measures: isSet(object.measures) ? SpendForecastMeasures.fromJSON(object.measures) : undefined,
+    };
+  },
+
+  toJSON(message: SpendForecastGroup): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.measures !== undefined) {
+      obj.measures = SpendForecastMeasures.toJSON(message.measures);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SpendForecastGroup>, I>>(base?: I): SpendForecastGroup {
+    return SpendForecastGroup.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SpendForecastGroup>, I>>(object: I): SpendForecastGroup {
+    const message = createBaseSpendForecastGroup();
+    message.key = object.key ?? "";
+    message.measures = (object.measures !== undefined && object.measures !== null)
+      ? SpendForecastMeasures.fromPartial(object.measures)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseSpendForecastMeasures(): SpendForecastMeasures {
+  return { monthToDateUsd: 0, projection: undefined };
+}
+
+export const SpendForecastMeasures: MessageFns<SpendForecastMeasures> = {
+  encode(message: SpendForecastMeasures, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.monthToDateUsd !== 0) {
+      writer.uint32(9).double(message.monthToDateUsd);
+    }
+    if (message.projection !== undefined) {
+      SpendProjection.encode(message.projection, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SpendForecastMeasures {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseSpendForecastMeasures();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 9) {
+              break;
+            }
+
+            message.monthToDateUsd = reader.double();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.projection = SpendProjection.decode(reader, reader.uint32());
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): SpendForecastMeasures {
+    return {
+      monthToDateUsd: isSet(object.monthToDateUsd)
+        ? globalThis.Number(object.monthToDateUsd)
+        : isSet(object.month_to_date_usd)
+        ? globalThis.Number(object.month_to_date_usd)
+        : 0,
+      projection: isSet(object.projection) ? SpendProjection.fromJSON(object.projection) : undefined,
+    };
+  },
+
+  toJSON(message: SpendForecastMeasures): unknown {
+    const obj: any = {};
+    if (message.monthToDateUsd !== 0) {
+      obj.monthToDateUsd = floatToJson(message.monthToDateUsd);
+    }
+    if (message.projection !== undefined) {
+      obj.projection = SpendProjection.toJSON(message.projection);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SpendForecastMeasures>, I>>(base?: I): SpendForecastMeasures {
+    return SpendForecastMeasures.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SpendForecastMeasures>, I>>(object: I): SpendForecastMeasures {
+    const message = createBaseSpendForecastMeasures();
+    message.monthToDateUsd = object.monthToDateUsd ?? 0;
+    message.projection = (object.projection !== undefined && object.projection !== null)
+      ? SpendProjection.fromPartial(object.projection)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseSpendProjection(): SpendProjection {
+  return { expectedUsd: 0, lowUsd: 0, highUsd: 0 };
+}
+
+export const SpendProjection: MessageFns<SpendProjection> = {
+  encode(message: SpendProjection, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.expectedUsd !== 0) {
+      writer.uint32(9).double(message.expectedUsd);
+    }
+    if (message.lowUsd !== 0) {
+      writer.uint32(17).double(message.lowUsd);
+    }
+    if (message.highUsd !== 0) {
+      writer.uint32(25).double(message.highUsd);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SpendProjection {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseSpendProjection();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 9) {
+              break;
+            }
+
+            message.expectedUsd = reader.double();
+            continue;
+          }
+          case 2: {
+            if (tag !== 17) {
+              break;
+            }
+
+            message.lowUsd = reader.double();
+            continue;
+          }
+          case 3: {
+            if (tag !== 25) {
+              break;
+            }
+
+            message.highUsd = reader.double();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): SpendProjection {
+    return {
+      expectedUsd: isSet(object.expectedUsd)
+        ? globalThis.Number(object.expectedUsd)
+        : isSet(object.expected_usd)
+        ? globalThis.Number(object.expected_usd)
+        : 0,
+      lowUsd: isSet(object.lowUsd)
+        ? globalThis.Number(object.lowUsd)
+        : isSet(object.low_usd)
+        ? globalThis.Number(object.low_usd)
+        : 0,
+      highUsd: isSet(object.highUsd)
+        ? globalThis.Number(object.highUsd)
+        : isSet(object.high_usd)
+        ? globalThis.Number(object.high_usd)
+        : 0,
+    };
+  },
+
+  toJSON(message: SpendProjection): unknown {
+    const obj: any = {};
+    if (message.expectedUsd !== 0) {
+      obj.expectedUsd = floatToJson(message.expectedUsd);
+    }
+    if (message.lowUsd !== 0) {
+      obj.lowUsd = floatToJson(message.lowUsd);
+    }
+    if (message.highUsd !== 0) {
+      obj.highUsd = floatToJson(message.highUsd);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SpendProjection>, I>>(base?: I): SpendProjection {
+    return SpendProjection.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SpendProjection>, I>>(object: I): SpendProjection {
+    const message = createBaseSpendProjection();
+    message.expectedUsd = object.expectedUsd ?? 0;
+    message.lowUsd = object.lowUsd ?? 0;
+    message.highUsd = object.highUsd ?? 0;
+    return message;
+  },
+};
+
+function createBaseActivityRhythmRequest(): ActivityRhythmRequest {
+  return { organizationId: "", projectId: "", timeWindow: 0, timeZone: "" };
+}
+
+export const ActivityRhythmRequest: MessageFns<ActivityRhythmRequest> = {
+  encode(message: ActivityRhythmRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.organizationId !== "") {
+      writer.uint32(10).string(message.organizationId);
+    }
+    if (message.projectId !== "") {
+      writer.uint32(18).string(message.projectId);
+    }
+    if (message.timeWindow !== 0) {
+      writer.uint32(24).int32(message.timeWindow);
+    }
+    if (message.timeZone !== "") {
+      writer.uint32(34).string(message.timeZone);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ActivityRhythmRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseActivityRhythmRequest();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.organizationId = reader.string();
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.projectId = reader.string();
+            continue;
+          }
+          case 3: {
+            if (tag !== 24) {
+              break;
+            }
+
+            message.timeWindow = reader.int32() as any;
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.timeZone = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ActivityRhythmRequest {
+    return {
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      timeWindow: isSet(object.timeWindow)
+        ? analyticsTimeWindowFromJSON(object.timeWindow)
+        : isSet(object.time_window)
+        ? analyticsTimeWindowFromJSON(object.time_window)
+        : 0,
+      timeZone: isSet(object.timeZone)
+        ? globalThis.String(object.timeZone)
+        : isSet(object.time_zone)
+        ? globalThis.String(object.time_zone)
+        : "",
+    };
+  },
+
+  toJSON(message: ActivityRhythmRequest): unknown {
+    const obj: any = {};
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.timeWindow !== 0) {
+      obj.timeWindow = analyticsTimeWindowToJSON(message.timeWindow);
+    }
+    if (message.timeZone !== "") {
+      obj.timeZone = message.timeZone;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ActivityRhythmRequest>, I>>(base?: I): ActivityRhythmRequest {
+    return ActivityRhythmRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ActivityRhythmRequest>, I>>(object: I): ActivityRhythmRequest {
+    const message = createBaseActivityRhythmRequest();
+    message.organizationId = object.organizationId ?? "";
+    message.projectId = object.projectId ?? "";
+    message.timeWindow = object.timeWindow ?? 0;
+    message.timeZone = object.timeZone ?? "";
+    return message;
+  },
+};
+
+function createBaseActivityRhythm(): ActivityRhythm {
+  return { buckets: [], windowStart: undefined, windowEnd: undefined, asOf: undefined, timeZone: "" };
+}
+
+export const ActivityRhythm: MessageFns<ActivityRhythm> = {
+  encode(message: ActivityRhythm, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.buckets) {
+      ActivityRhythmBucket.encode(v!, writer.uint32(10).fork()).join();
+    }
+    if (message.windowStart !== undefined) {
+      Timestamp.encode(toTimestamp(message.windowStart), writer.uint32(18).fork()).join();
+    }
+    if (message.windowEnd !== undefined) {
+      Timestamp.encode(toTimestamp(message.windowEnd), writer.uint32(26).fork()).join();
+    }
+    if (message.asOf !== undefined) {
+      Timestamp.encode(toTimestamp(message.asOf), writer.uint32(34).fork()).join();
+    }
+    if (message.timeZone !== "") {
+      writer.uint32(42).string(message.timeZone);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ActivityRhythm {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
+    if (previousRecursionDepth >= 100) {
+      throw new globalThis.Error("protobuf decode recursion limit exceeded");
+    }
+    (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
+    try {
+      const end = length === undefined ? reader.len : reader.pos + length;
+      const message = createBaseActivityRhythm();
+      while (reader.pos < end) {
+        const tag = reader.uint32();
+        switch (tag >>> 3) {
+          case 1: {
+            if (tag !== 10) {
+              break;
+            }
+
+            message.buckets.push(ActivityRhythmBucket.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 2: {
+            if (tag !== 18) {
+              break;
+            }
+
+            message.windowStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 3: {
+            if (tag !== 26) {
+              break;
+            }
+
+            message.windowEnd = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 4: {
+            if (tag !== 34) {
+              break;
+            }
+
+            message.asOf = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+            continue;
+          }
+          case 5: {
+            if (tag !== 42) {
+              break;
+            }
+
+            message.timeZone = reader.string();
+            continue;
+          }
+        }
+        if ((tag & 7) === 4 || tag === 0) {
+          break;
+        }
+        reader.skip(tag & 7);
+      }
+      return message;
+    } finally {
+      (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
+    }
+  },
+
+  fromJSON(object: any): ActivityRhythm {
+    return {
+      buckets: globalThis.Array.isArray(object?.buckets)
+        ? object.buckets.map((e: any) => ActivityRhythmBucket.fromJSON(e))
+        : [],
+      windowStart: isSet(object.windowStart)
+        ? fromJsonTimestamp(object.windowStart)
+        : isSet(object.window_start)
+        ? fromJsonTimestamp(object.window_start)
+        : undefined,
+      windowEnd: isSet(object.windowEnd)
+        ? fromJsonTimestamp(object.windowEnd)
+        : isSet(object.window_end)
+        ? fromJsonTimestamp(object.window_end)
+        : undefined,
+      asOf: isSet(object.asOf)
+        ? fromJsonTimestamp(object.asOf)
+        : isSet(object.as_of)
+        ? fromJsonTimestamp(object.as_of)
+        : undefined,
+      timeZone: isSet(object.timeZone)
+        ? globalThis.String(object.timeZone)
+        : isSet(object.time_zone)
+        ? globalThis.String(object.time_zone)
+        : "",
+    };
+  },
+
+  toJSON(message: ActivityRhythm): unknown {
+    const obj: any = {};
+    if (message.buckets?.length) {
+      obj.buckets = message.buckets.map((e) => ActivityRhythmBucket.toJSON(e));
+    }
+    if (message.windowStart !== undefined) {
+      obj.windowStart = message.windowStart.toISOString();
+    }
+    if (message.windowEnd !== undefined) {
+      obj.windowEnd = message.windowEnd.toISOString();
     }
     if (message.asOf !== undefined) {
       obj.asOf = message.asOf.toISOString();
@@ -20817,6 +21738,13 @@ export interface AIGatewayService {
    * omitted; today is provisional.
    */
   StreamDailyActivity(request: DailyActivityRequest, metadata?: Metadata): Observable<DailyActivity>;
+  /**
+   * Live current-UTC-month spend forecast: month-to-date cost and the projected month-end total (a band from
+   * replaying recent weeks), for the project and per model, provider, source system, user and api key, off the
+   * same daily rollup as StreamDailyActivity; filter.funding_modes forecasts the cost on the listed funding modes. Mirrors
+   * telemetry.api.v1.
+   */
+  StreamSpendForecast(request: SpendForecastRequest, metadata?: Metadata): Observable<SpendForecast>;
   /**
    * Live weekly activity rhythm: a sparse (weekday, hour) heatmap over a bounded sliding window in an
    * explicit IANA time zone. Every latest logical event counts; settled model calls add token/cost.
@@ -20903,6 +21831,7 @@ export class AIGatewayServiceClientImpl implements AIGatewayService {
     this.StreamTokenActivitySummary = this.StreamTokenActivitySummary.bind(this);
     this.StreamBurnRate = this.StreamBurnRate.bind(this);
     this.StreamDailyActivity = this.StreamDailyActivity.bind(this);
+    this.StreamSpendForecast = this.StreamSpendForecast.bind(this);
     this.StreamActivityRhythm = this.StreamActivityRhythm.bind(this);
     this.StreamProjectOverview = this.StreamProjectOverview.bind(this);
     this.StreamProjectSummaries = this.StreamProjectSummaries.bind(this);
@@ -21000,6 +21929,12 @@ export class AIGatewayServiceClientImpl implements AIGatewayService {
     return result.pipe(map((data) => DailyActivity.decode(new BinaryReader(data))));
   }
 
+  StreamSpendForecast(request: SpendForecastRequest, metadata?: Metadata): Observable<SpendForecast> {
+    const data = SpendForecastRequest.encode(request).finish();
+    const result = this.rpc.serverStreamingRequest(this.service, "StreamSpendForecast", data, metadata);
+    return result.pipe(map((data) => SpendForecast.decode(new BinaryReader(data))));
+  }
+
   StreamActivityRhythm(request: ActivityRhythmRequest, metadata?: Metadata): Observable<ActivityRhythm> {
     const data = ActivityRhythmRequest.encode(request).finish();
     const result = this.rpc.serverStreamingRequest(this.service, "StreamActivityRhythm", data, metadata);