@miradorlabs/web-grpc 2.16.0 → 2.17.0

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

@@ -15,6 +15,90 @@ import { EnabledStatus, enabledStatusFromJSON, enabledStatusToJSON } from "./com
 
 export const protobufPackage = "gateway.web.v1";
 
+export enum Severity {
+  SEVERITY_UNSPECIFIED = 0,
+  SEVERITY_INFO = 1,
+  SEVERITY_WARNING = 2,
+  SEVERITY_CRITICAL = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function severityFromJSON(object: any): Severity {
+  switch (object) {
+    case 0:
+    case "SEVERITY_UNSPECIFIED":
+      return Severity.SEVERITY_UNSPECIFIED;
+    case 1:
+    case "SEVERITY_INFO":
+      return Severity.SEVERITY_INFO;
+    case 2:
+    case "SEVERITY_WARNING":
+      return Severity.SEVERITY_WARNING;
+    case 3:
+    case "SEVERITY_CRITICAL":
+      return Severity.SEVERITY_CRITICAL;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return Severity.UNRECOGNIZED;
+  }
+}
+
+export function severityToJSON(object: Severity): string {
+  switch (object) {
+    case Severity.SEVERITY_UNSPECIFIED:
+      return "SEVERITY_UNSPECIFIED";
+    case Severity.SEVERITY_INFO:
+      return "SEVERITY_INFO";
+    case Severity.SEVERITY_WARNING:
+      return "SEVERITY_WARNING";
+    case Severity.SEVERITY_CRITICAL:
+      return "SEVERITY_CRITICAL";
+    case Severity.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export enum MetricActivityType {
+  METRIC_ACTIVITY_TYPE_UNSPECIFIED = 0,
+  METRIC_ACTIVITY_TYPE_TRIGGERED = 1,
+  METRIC_ACTIVITY_TYPE_RECOVERED = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function metricActivityTypeFromJSON(object: any): MetricActivityType {
+  switch (object) {
+    case 0:
+    case "METRIC_ACTIVITY_TYPE_UNSPECIFIED":
+      return MetricActivityType.METRIC_ACTIVITY_TYPE_UNSPECIFIED;
+    case 1:
+    case "METRIC_ACTIVITY_TYPE_TRIGGERED":
+      return MetricActivityType.METRIC_ACTIVITY_TYPE_TRIGGERED;
+    case 2:
+    case "METRIC_ACTIVITY_TYPE_RECOVERED":
+      return MetricActivityType.METRIC_ACTIVITY_TYPE_RECOVERED;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return MetricActivityType.UNRECOGNIZED;
+  }
+}
+
+export function metricActivityTypeToJSON(object: MetricActivityType): string {
+  switch (object) {
+    case MetricActivityType.METRIC_ACTIVITY_TYPE_UNSPECIFIED:
+      return "METRIC_ACTIVITY_TYPE_UNSPECIFIED";
+    case MetricActivityType.METRIC_ACTIVITY_TYPE_TRIGGERED:
+      return "METRIC_ACTIVITY_TYPE_TRIGGERED";
+    case MetricActivityType.METRIC_ACTIVITY_TYPE_RECOVERED:
+      return "METRIC_ACTIVITY_TYPE_RECOVERED";
+    case MetricActivityType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 export interface TraceRule {
   id: string;
   projectId: string;
@@ -131,39 +215,168 @@ export interface TraceRuleSchema {
   jsonSchema: string;
 }
 
-export interface StreamTraceRuleMatchesRequest {
+export interface StreamTraceRuleActivityRequest {
   projectId: string;
   organizationId: string;
   limit: number;
 }
 
-export interface TraceRuleMatchEnvelope {
-  snapshot?: TraceRuleMatchSnapshot | undefined;
-  update?: TraceRuleMatchEvent | undefined;
+export interface TraceRuleActivityEnvelope {
+  snapshot?: TraceRuleActivitySnapshot | undefined;
+  update?: TraceRuleActivityEvent | undefined;
 }
 
-export interface TraceRuleMatchSnapshot {
-  matches: TraceRuleMatchEvent[];
+export interface TraceRuleActivitySnapshot {
+  activities: TraceRuleActivityEvent[];
 }
 
-export interface TraceRuleMatchEvent {
-  matchId: string;
-  projectId: string;
+export interface TraceRuleActivityEvent {
+  activityId: string;
   ruleId: string;
   ruleName: string;
-  integrationIds: string[];
+  traceId: string;
+  admittedTraceVersion: number;
+  traceName: string;
   matchReason: string;
+  occurredAt: Date | undefined;
+}
+
+export interface MetricRule {
+  id: string;
+  projectId: string;
+  organizationId: string;
+  name: string;
+  description: string;
+  enabled: EnabledStatus;
+  integrationIds: string[];
+  condition: MetricRuleCondition | undefined;
+  evaluationIntervalSeconds: number;
+  severity: Severity;
   createdAt: Date | undefined;
-  entityContexts: TraceRuleMatchEvent_EntityContext[];
+  updatedAt: Date | undefined;
 }
 
-/** EntityContext carries contextual data about a matched entity. */
-export interface TraceRuleMatchEvent_EntityContext {
-  traceContext?: TraceRuleMatchEvent_EntityContext_TraceContext | undefined;
+export interface MetricRuleCondition {
+  expression: string;
+  recoveryExpression?: string | undefined;
 }
 
-export interface TraceRuleMatchEvent_EntityContext_TraceContext {
-  traceId: string;
+export interface CreateMetricRuleRequest {
+  projectId: string;
+  name: string;
+  description: string;
+  integrationIds: string[];
+  condition: MetricRuleCondition | undefined;
+  evaluationIntervalSeconds: number;
+  severity: Severity;
+  organizationId: string;
+}
+
+export interface CreateMetricRuleResponse {
+  status: ResponseStatus | undefined;
+  metricRule: MetricRule | undefined;
+}
+
+export interface GetMetricRuleRequest {
+  projectId: string;
+  metricRuleId: string;
+  organizationId: string;
+}
+
+export interface GetMetricRuleResponse {
+  status: ResponseStatus | undefined;
+  metricRule: MetricRule | undefined;
+}
+
+export interface ListMetricRulesRequest {
+  organizationId: string;
+  organizationIdFilter?: string | undefined;
+  projectIdFilter?: string | undefined;
+}
+
+export interface ListMetricRulesResponse {
+  status: ResponseStatus | undefined;
+  metricRules: MetricRule[];
+}
+
+export interface UpdateMetricRuleRequest {
+  projectId: string;
+  metricRuleId: string;
+  updates: UpdateMetricRuleRequest_MetricRuleUpdates | undefined;
+  organizationId: string;
+}
+
+export interface UpdateMetricRuleRequest_Condition {
+  condition: MetricRuleCondition | undefined;
+}
+
+export interface UpdateMetricRuleRequest_IntegrationIds {
+  ids: string[];
+}
+
+export interface UpdateMetricRuleRequest_MetricRuleUpdates {
+  name?: string | undefined;
+  description?: string | undefined;
+  enabled?: EnabledStatus | undefined;
+  evaluationIntervalSeconds?: number | undefined;
+  severity?: Severity | undefined;
+  integrationIds: UpdateMetricRuleRequest_IntegrationIds | undefined;
+  condition: UpdateMetricRuleRequest_Condition | undefined;
+}
+
+export interface UpdateMetricRuleResponse {
+  status: ResponseStatus | undefined;
+  metricRule: MetricRule | undefined;
+}
+
+export interface DeleteMetricRuleRequest {
+  projectId: string;
+  metricRuleId: string;
+  organizationId: string;
+}
+
+export interface DeleteMetricRuleResponse {
+  status: ResponseStatus | undefined;
+}
+
+export interface PreviewMetricRuleRequest {
+  projectId: string;
+  expression: string;
+  organizationId: string;
+}
+
+export interface PreviewMetricRuleResponse {
+  status: ResponseStatus | undefined;
+  value?: number | undefined;
+  wouldFire: boolean;
+  state: string;
+}
+
+export interface StreamMetricRuleActivityRequest {
+  projectId: string;
+  organizationId: string;
+  limit: number;
+}
+
+export interface MetricRuleActivityEnvelope {
+  snapshot?: MetricRuleActivitySnapshot | undefined;
+  update?: MetricRuleActivityEvent | undefined;
+}
+
+export interface MetricRuleActivitySnapshot {
+  activities: MetricRuleActivityEvent[];
+}
+
+export interface MetricRuleActivityEvent {
+  activityId: string;
+  ruleId: string;
+  ruleName: string;
+  type: MetricActivityType;
+  incidentId: string;
+  expression: string;
+  observedValue: number;
+  severity: Severity;
+  occurredAt: Date | undefined;
 }
 
 function createBaseTraceRule(): TraceRule {
@@ -2130,12 +2343,12 @@ export const TraceRuleSchema: MessageFns<TraceRuleSchema> = {
   },
 };
 
-function createBaseStreamTraceRuleMatchesRequest(): StreamTraceRuleMatchesRequest {
+function createBaseStreamTraceRuleActivityRequest(): StreamTraceRuleActivityRequest {
   return { projectId: "", organizationId: "", limit: 0 };
 }
 
-export const StreamTraceRuleMatchesRequest: MessageFns<StreamTraceRuleMatchesRequest> = {
-  encode(message: StreamTraceRuleMatchesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const StreamTraceRuleActivityRequest: MessageFns<StreamTraceRuleActivityRequest> = {
+  encode(message: StreamTraceRuleActivityRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.projectId !== "") {
       writer.uint32(10).string(message.projectId);
     }
@@ -2148,10 +2361,10 @@ export const StreamTraceRuleMatchesRequest: MessageFns<StreamTraceRuleMatchesReq
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): StreamTraceRuleMatchesRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): StreamTraceRuleActivityRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseStreamTraceRuleMatchesRequest();
+    const message = createBaseStreamTraceRuleActivityRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2188,7 +2401,7 @@ export const StreamTraceRuleMatchesRequest: MessageFns<StreamTraceRuleMatchesReq
     return message;
   },
 
-  fromJSON(object: any): StreamTraceRuleMatchesRequest {
+  fromJSON(object: any): StreamTraceRuleActivityRequest {
     return {
       projectId: isSet(object.projectId)
         ? globalThis.String(object.projectId)
@@ -2204,7 +2417,7 @@ export const StreamTraceRuleMatchesRequest: MessageFns<StreamTraceRuleMatchesReq
     };
   },
 
-  toJSON(message: StreamTraceRuleMatchesRequest): unknown {
+  toJSON(message: StreamTraceRuleActivityRequest): unknown {
     const obj: any = {};
     if (message.projectId !== "") {
       obj.projectId = message.projectId;
@@ -2218,13 +2431,13 @@ export const StreamTraceRuleMatchesRequest: MessageFns<StreamTraceRuleMatchesReq
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<StreamTraceRuleMatchesRequest>, I>>(base?: I): StreamTraceRuleMatchesRequest {
-    return StreamTraceRuleMatchesRequest.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<StreamTraceRuleActivityRequest>, I>>(base?: I): StreamTraceRuleActivityRequest {
+    return StreamTraceRuleActivityRequest.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<StreamTraceRuleMatchesRequest>, I>>(
+  fromPartial<I extends Exact<DeepPartial<StreamTraceRuleActivityRequest>, I>>(
     object: I,
-  ): StreamTraceRuleMatchesRequest {
-    const message = createBaseStreamTraceRuleMatchesRequest();
+  ): StreamTraceRuleActivityRequest {
+    const message = createBaseStreamTraceRuleActivityRequest();
     message.projectId = object.projectId ?? "";
     message.organizationId = object.organizationId ?? "";
     message.limit = object.limit ?? 0;
@@ -2232,25 +2445,25 @@ export const StreamTraceRuleMatchesRequest: MessageFns<StreamTraceRuleMatchesReq
   },
 };
 
-function createBaseTraceRuleMatchEnvelope(): TraceRuleMatchEnvelope {
+function createBaseTraceRuleActivityEnvelope(): TraceRuleActivityEnvelope {
   return { snapshot: undefined, update: undefined };
 }
 
-export const TraceRuleMatchEnvelope: MessageFns<TraceRuleMatchEnvelope> = {
-  encode(message: TraceRuleMatchEnvelope, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const TraceRuleActivityEnvelope: MessageFns<TraceRuleActivityEnvelope> = {
+  encode(message: TraceRuleActivityEnvelope, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.snapshot !== undefined) {
-      TraceRuleMatchSnapshot.encode(message.snapshot, writer.uint32(10).fork()).join();
+      TraceRuleActivitySnapshot.encode(message.snapshot, writer.uint32(10).fork()).join();
     }
     if (message.update !== undefined) {
-      TraceRuleMatchEvent.encode(message.update, writer.uint32(18).fork()).join();
+      TraceRuleActivityEvent.encode(message.update, writer.uint32(18).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): TraceRuleMatchEnvelope {
+  decode(input: BinaryReader | Uint8Array, length?: number): TraceRuleActivityEnvelope {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTraceRuleMatchEnvelope();
+    const message = createBaseTraceRuleActivityEnvelope();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2259,7 +2472,7 @@ export const TraceRuleMatchEnvelope: MessageFns<TraceRuleMatchEnvelope> = {
             break;
           }
 
-          message.snapshot = TraceRuleMatchSnapshot.decode(reader, reader.uint32());
+          message.snapshot = TraceRuleActivitySnapshot.decode(reader, reader.uint32());
           continue;
         }
         case 2: {
@@ -2267,7 +2480,7 @@ export const TraceRuleMatchEnvelope: MessageFns<TraceRuleMatchEnvelope> = {
             break;
           }
 
-          message.update = TraceRuleMatchEvent.decode(reader, reader.uint32());
+          message.update = TraceRuleActivityEvent.decode(reader, reader.uint32());
           continue;
         }
       }
@@ -2279,55 +2492,55 @@ export const TraceRuleMatchEnvelope: MessageFns<TraceRuleMatchEnvelope> = {
     return message;
   },
 
-  fromJSON(object: any): TraceRuleMatchEnvelope {
+  fromJSON(object: any): TraceRuleActivityEnvelope {
     return {
-      snapshot: isSet(object.snapshot) ? TraceRuleMatchSnapshot.fromJSON(object.snapshot) : undefined,
-      update: isSet(object.update) ? TraceRuleMatchEvent.fromJSON(object.update) : undefined,
+      snapshot: isSet(object.snapshot) ? TraceRuleActivitySnapshot.fromJSON(object.snapshot) : undefined,
+      update: isSet(object.update) ? TraceRuleActivityEvent.fromJSON(object.update) : undefined,
     };
   },
 
-  toJSON(message: TraceRuleMatchEnvelope): unknown {
+  toJSON(message: TraceRuleActivityEnvelope): unknown {
     const obj: any = {};
     if (message.snapshot !== undefined) {
-      obj.snapshot = TraceRuleMatchSnapshot.toJSON(message.snapshot);
+      obj.snapshot = TraceRuleActivitySnapshot.toJSON(message.snapshot);
     }
     if (message.update !== undefined) {
-      obj.update = TraceRuleMatchEvent.toJSON(message.update);
+      obj.update = TraceRuleActivityEvent.toJSON(message.update);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<TraceRuleMatchEnvelope>, I>>(base?: I): TraceRuleMatchEnvelope {
-    return TraceRuleMatchEnvelope.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<TraceRuleActivityEnvelope>, I>>(base?: I): TraceRuleActivityEnvelope {
+    return TraceRuleActivityEnvelope.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<TraceRuleMatchEnvelope>, I>>(object: I): TraceRuleMatchEnvelope {
-    const message = createBaseTraceRuleMatchEnvelope();
+  fromPartial<I extends Exact<DeepPartial<TraceRuleActivityEnvelope>, I>>(object: I): TraceRuleActivityEnvelope {
+    const message = createBaseTraceRuleActivityEnvelope();
     message.snapshot = (object.snapshot !== undefined && object.snapshot !== null)
-      ? TraceRuleMatchSnapshot.fromPartial(object.snapshot)
+      ? TraceRuleActivitySnapshot.fromPartial(object.snapshot)
       : undefined;
     message.update = (object.update !== undefined && object.update !== null)
-      ? TraceRuleMatchEvent.fromPartial(object.update)
+      ? TraceRuleActivityEvent.fromPartial(object.update)
       : undefined;
     return message;
   },
 };
 
-function createBaseTraceRuleMatchSnapshot(): TraceRuleMatchSnapshot {
-  return { matches: [] };
+function createBaseTraceRuleActivitySnapshot(): TraceRuleActivitySnapshot {
+  return { activities: [] };
 }
 
-export const TraceRuleMatchSnapshot: MessageFns<TraceRuleMatchSnapshot> = {
-  encode(message: TraceRuleMatchSnapshot, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    for (const v of message.matches) {
-      TraceRuleMatchEvent.encode(v!, writer.uint32(10).fork()).join();
+export const TraceRuleActivitySnapshot: MessageFns<TraceRuleActivitySnapshot> = {
+  encode(message: TraceRuleActivitySnapshot, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.activities) {
+      TraceRuleActivityEvent.encode(v!, writer.uint32(10).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): TraceRuleMatchSnapshot {
+  decode(input: BinaryReader | Uint8Array, length?: number): TraceRuleActivitySnapshot {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTraceRuleMatchSnapshot();
+    const message = createBaseTraceRuleActivitySnapshot();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2336,7 +2549,7 @@ export const TraceRuleMatchSnapshot: MessageFns<TraceRuleMatchSnapshot> = {
             break;
           }
 
-          message.matches.push(TraceRuleMatchEvent.decode(reader, reader.uint32()));
+          message.activities.push(TraceRuleActivityEvent.decode(reader, reader.uint32()));
           continue;
         }
       }
@@ -2348,78 +2561,78 @@ export const TraceRuleMatchSnapshot: MessageFns<TraceRuleMatchSnapshot> = {
     return message;
   },
 
-  fromJSON(object: any): TraceRuleMatchSnapshot {
+  fromJSON(object: any): TraceRuleActivitySnapshot {
     return {
-      matches: globalThis.Array.isArray(object?.matches)
-        ? object.matches.map((e: any) => TraceRuleMatchEvent.fromJSON(e))
+      activities: globalThis.Array.isArray(object?.activities)
+        ? object.activities.map((e: any) => TraceRuleActivityEvent.fromJSON(e))
         : [],
     };
   },
 
-  toJSON(message: TraceRuleMatchSnapshot): unknown {
+  toJSON(message: TraceRuleActivitySnapshot): unknown {
     const obj: any = {};
-    if (message.matches?.length) {
-      obj.matches = message.matches.map((e) => TraceRuleMatchEvent.toJSON(e));
+    if (message.activities?.length) {
+      obj.activities = message.activities.map((e) => TraceRuleActivityEvent.toJSON(e));
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<TraceRuleMatchSnapshot>, I>>(base?: I): TraceRuleMatchSnapshot {
-    return TraceRuleMatchSnapshot.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<TraceRuleActivitySnapshot>, I>>(base?: I): TraceRuleActivitySnapshot {
+    return TraceRuleActivitySnapshot.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<TraceRuleMatchSnapshot>, I>>(object: I): TraceRuleMatchSnapshot {
-    const message = createBaseTraceRuleMatchSnapshot();
-    message.matches = object.matches?.map((e) => TraceRuleMatchEvent.fromPartial(e)) || [];
+  fromPartial<I extends Exact<DeepPartial<TraceRuleActivitySnapshot>, I>>(object: I): TraceRuleActivitySnapshot {
+    const message = createBaseTraceRuleActivitySnapshot();
+    message.activities = object.activities?.map((e) => TraceRuleActivityEvent.fromPartial(e)) || [];
     return message;
   },
 };
 
-function createBaseTraceRuleMatchEvent(): TraceRuleMatchEvent {
+function createBaseTraceRuleActivityEvent(): TraceRuleActivityEvent {
   return {
-    matchId: "",
-    projectId: "",
+    activityId: "",
     ruleId: "",
     ruleName: "",
-    integrationIds: [],
+    traceId: "",
+    admittedTraceVersion: 0,
+    traceName: "",
     matchReason: "",
-    createdAt: undefined,
-    entityContexts: [],
+    occurredAt: undefined,
   };
 }
 
-export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
-  encode(message: TraceRuleMatchEvent, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.matchId !== "") {
-      writer.uint32(10).string(message.matchId);
-    }
-    if (message.projectId !== "") {
-      writer.uint32(18).string(message.projectId);
+export const TraceRuleActivityEvent: MessageFns<TraceRuleActivityEvent> = {
+  encode(message: TraceRuleActivityEvent, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.activityId !== "") {
+      writer.uint32(10).string(message.activityId);
     }
     if (message.ruleId !== "") {
-      writer.uint32(26).string(message.ruleId);
+      writer.uint32(18).string(message.ruleId);
     }
     if (message.ruleName !== "") {
-      writer.uint32(34).string(message.ruleName);
+      writer.uint32(26).string(message.ruleName);
     }
-    for (const v of message.integrationIds) {
-      writer.uint32(42).string(v!);
+    if (message.traceId !== "") {
+      writer.uint32(34).string(message.traceId);
     }
-    if (message.matchReason !== "") {
-      writer.uint32(50).string(message.matchReason);
+    if (message.admittedTraceVersion !== 0) {
+      writer.uint32(40).uint64(message.admittedTraceVersion);
     }
-    if (message.createdAt !== undefined) {
-      Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(58).fork()).join();
+    if (message.traceName !== "") {
+      writer.uint32(50).string(message.traceName);
+    }
+    if (message.matchReason !== "") {
+      writer.uint32(58).string(message.matchReason);
     }
-    for (const v of message.entityContexts) {
-      TraceRuleMatchEvent_EntityContext.encode(v!, writer.uint32(66).fork()).join();
+    if (message.occurredAt !== undefined) {
+      Timestamp.encode(toTimestamp(message.occurredAt), writer.uint32(66).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): TraceRuleMatchEvent {
+  decode(input: BinaryReader | Uint8Array, length?: number): TraceRuleActivityEvent {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTraceRuleMatchEvent();
+    const message = createBaseTraceRuleActivityEvent();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2428,7 +2641,7 @@ export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
             break;
           }
 
-          message.matchId = reader.string();
+          message.activityId = reader.string();
           continue;
         }
         case 2: {
@@ -2436,7 +2649,7 @@ export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
             break;
           }
 
-          message.projectId = reader.string();
+          message.ruleId = reader.string();
           continue;
         }
         case 3: {
@@ -2444,7 +2657,7 @@ export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
             break;
           }
 
-          message.ruleId = reader.string();
+          message.ruleName = reader.string();
           continue;
         }
         case 4: {
@@ -2452,15 +2665,15 @@ export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
             break;
           }
 
-          message.ruleName = reader.string();
+          message.traceId = reader.string();
           continue;
         }
         case 5: {
-          if (tag !== 42) {
+          if (tag !== 40) {
             break;
           }
 
-          message.integrationIds.push(reader.string());
+          message.admittedTraceVersion = longToNumber(reader.uint64());
           continue;
         }
         case 6: {
@@ -2468,7 +2681,7 @@ export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
             break;
           }
 
-          message.matchReason = reader.string();
+          message.traceName = reader.string();
           continue;
         }
         case 7: {
@@ -2476,7 +2689,7 @@ export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
             break;
           }
 
-          message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          message.matchReason = reader.string();
           continue;
         }
         case 8: {
@@ -2484,7 +2697,7 @@ export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
             break;
           }
 
-          message.entityContexts.push(TraceRuleMatchEvent_EntityContext.decode(reader, reader.uint32()));
+          message.occurredAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           continue;
         }
       }
@@ -2496,17 +2709,12 @@ export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
     return message;
   },
 
-  fromJSON(object: any): TraceRuleMatchEvent {
+  fromJSON(object: any): TraceRuleActivityEvent {
     return {
-      matchId: isSet(object.matchId)
-        ? globalThis.String(object.matchId)
-        : isSet(object.match_id)
-        ? globalThis.String(object.match_id)
-        : "",
-      projectId: isSet(object.projectId)
-        ? globalThis.String(object.projectId)
-        : isSet(object.project_id)
-        ? globalThis.String(object.project_id)
+      activityId: isSet(object.activityId)
+        ? globalThis.String(object.activityId)
+        : isSet(object.activity_id)
+        ? globalThis.String(object.activity_id)
         : "",
       ruleId: isSet(object.ruleId)
         ? globalThis.String(object.ruleId)
@@ -2518,36 +2726,38 @@ export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
         : isSet(object.rule_name)
         ? globalThis.String(object.rule_name)
         : "",
-      integrationIds: globalThis.Array.isArray(object?.integrationIds)
-        ? object.integrationIds.map((e: any) => globalThis.String(e))
-        : globalThis.Array.isArray(object?.integration_ids)
-        ? object.integration_ids.map((e: any) => globalThis.String(e))
-        : [],
+      traceId: isSet(object.traceId)
+        ? globalThis.String(object.traceId)
+        : isSet(object.trace_id)
+        ? globalThis.String(object.trace_id)
+        : "",
+      admittedTraceVersion: isSet(object.admittedTraceVersion)
+        ? globalThis.Number(object.admittedTraceVersion)
+        : isSet(object.admitted_trace_version)
+        ? globalThis.Number(object.admitted_trace_version)
+        : 0,
+      traceName: isSet(object.traceName)
+        ? globalThis.String(object.traceName)
+        : isSet(object.trace_name)
+        ? globalThis.String(object.trace_name)
+        : "",
       matchReason: isSet(object.matchReason)
         ? globalThis.String(object.matchReason)
         : isSet(object.match_reason)
         ? globalThis.String(object.match_reason)
         : "",
-      createdAt: isSet(object.createdAt)
-        ? fromJsonTimestamp(object.createdAt)
-        : isSet(object.created_at)
-        ? fromJsonTimestamp(object.created_at)
+      occurredAt: isSet(object.occurredAt)
+        ? fromJsonTimestamp(object.occurredAt)
+        : isSet(object.occurred_at)
+        ? fromJsonTimestamp(object.occurred_at)
         : undefined,
-      entityContexts: globalThis.Array.isArray(object?.entityContexts)
-        ? object.entityContexts.map((e: any) => TraceRuleMatchEvent_EntityContext.fromJSON(e))
-        : globalThis.Array.isArray(object?.entity_contexts)
-        ? object.entity_contexts.map((e: any) => TraceRuleMatchEvent_EntityContext.fromJSON(e))
-        : [],
     };
   },
 
-  toJSON(message: TraceRuleMatchEvent): unknown {
+  toJSON(message: TraceRuleActivityEvent): unknown {
     const obj: any = {};
-    if (message.matchId !== "") {
-      obj.matchId = message.matchId;
-    }
-    if (message.projectId !== "") {
-      obj.projectId = message.projectId;
+    if (message.activityId !== "") {
+      obj.activityId = message.activityId;
     }
     if (message.ruleId !== "") {
       obj.ruleId = message.ruleId;
@@ -2555,54 +2765,103 @@ export const TraceRuleMatchEvent: MessageFns<TraceRuleMatchEvent> = {
     if (message.ruleName !== "") {
       obj.ruleName = message.ruleName;
     }
-    if (message.integrationIds?.length) {
-      obj.integrationIds = message.integrationIds;
+    if (message.traceId !== "") {
+      obj.traceId = message.traceId;
+    }
+    if (message.admittedTraceVersion !== 0) {
+      obj.admittedTraceVersion = Math.round(message.admittedTraceVersion);
+    }
+    if (message.traceName !== "") {
+      obj.traceName = message.traceName;
     }
     if (message.matchReason !== "") {
       obj.matchReason = message.matchReason;
     }
-    if (message.createdAt !== undefined) {
-      obj.createdAt = message.createdAt.toISOString();
-    }
-    if (message.entityContexts?.length) {
-      obj.entityContexts = message.entityContexts.map((e) => TraceRuleMatchEvent_EntityContext.toJSON(e));
+    if (message.occurredAt !== undefined) {
+      obj.occurredAt = message.occurredAt.toISOString();
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<TraceRuleMatchEvent>, I>>(base?: I): TraceRuleMatchEvent {
-    return TraceRuleMatchEvent.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<TraceRuleActivityEvent>, I>>(base?: I): TraceRuleActivityEvent {
+    return TraceRuleActivityEvent.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<TraceRuleMatchEvent>, I>>(object: I): TraceRuleMatchEvent {
-    const message = createBaseTraceRuleMatchEvent();
-    message.matchId = object.matchId ?? "";
-    message.projectId = object.projectId ?? "";
+  fromPartial<I extends Exact<DeepPartial<TraceRuleActivityEvent>, I>>(object: I): TraceRuleActivityEvent {
+    const message = createBaseTraceRuleActivityEvent();
+    message.activityId = object.activityId ?? "";
     message.ruleId = object.ruleId ?? "";
     message.ruleName = object.ruleName ?? "";
-    message.integrationIds = object.integrationIds?.map((e) => e) || [];
+    message.traceId = object.traceId ?? "";
+    message.admittedTraceVersion = object.admittedTraceVersion ?? 0;
+    message.traceName = object.traceName ?? "";
     message.matchReason = object.matchReason ?? "";
-    message.createdAt = object.createdAt ?? undefined;
-    message.entityContexts = object.entityContexts?.map((e) => TraceRuleMatchEvent_EntityContext.fromPartial(e)) || [];
+    message.occurredAt = object.occurredAt ?? undefined;
     return message;
   },
 };
 
-function createBaseTraceRuleMatchEvent_EntityContext(): TraceRuleMatchEvent_EntityContext {
-  return { traceContext: undefined };
+function createBaseMetricRule(): MetricRule {
+  return {
+    id: "",
+    projectId: "",
+    organizationId: "",
+    name: "",
+    description: "",
+    enabled: 0,
+    integrationIds: [],
+    condition: undefined,
+    evaluationIntervalSeconds: 0,
+    severity: 0,
+    createdAt: undefined,
+    updatedAt: undefined,
+  };
 }
 
-export const TraceRuleMatchEvent_EntityContext: MessageFns<TraceRuleMatchEvent_EntityContext> = {
-  encode(message: TraceRuleMatchEvent_EntityContext, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.traceContext !== undefined) {
-      TraceRuleMatchEvent_EntityContext_TraceContext.encode(message.traceContext, writer.uint32(10).fork()).join();
+export const MetricRule: MessageFns<MetricRule> = {
+  encode(message: MetricRule, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.projectId !== "") {
+      writer.uint32(18).string(message.projectId);
+    }
+    if (message.organizationId !== "") {
+      writer.uint32(26).string(message.organizationId);
+    }
+    if (message.name !== "") {
+      writer.uint32(34).string(message.name);
+    }
+    if (message.description !== "") {
+      writer.uint32(42).string(message.description);
+    }
+    if (message.enabled !== 0) {
+      writer.uint32(48).int32(message.enabled);
+    }
+    for (const v of message.integrationIds) {
+      writer.uint32(58).string(v!);
+    }
+    if (message.condition !== undefined) {
+      MetricRuleCondition.encode(message.condition, writer.uint32(66).fork()).join();
+    }
+    if (message.evaluationIntervalSeconds !== 0) {
+      writer.uint32(72).int64(message.evaluationIntervalSeconds);
+    }
+    if (message.severity !== 0) {
+      writer.uint32(80).int32(message.severity);
+    }
+    if (message.createdAt !== undefined) {
+      Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(90).fork()).join();
+    }
+    if (message.updatedAt !== undefined) {
+      Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(98).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): TraceRuleMatchEvent_EntityContext {
+  decode(input: BinaryReader | Uint8Array, length?: number): MetricRule {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTraceRuleMatchEvent_EntityContext();
+    const message = createBaseMetricRule();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2611,85 +2870,1979 @@ export const TraceRuleMatchEvent_EntityContext: MessageFns<TraceRuleMatchEvent_E
             break;
           }
 
-          message.traceContext = TraceRuleMatchEvent_EntityContext_TraceContext.decode(reader, reader.uint32());
+          message.id = reader.string();
           continue;
         }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-
-  fromJSON(object: any): TraceRuleMatchEvent_EntityContext {
-    return {
-      traceContext: isSet(object.traceContext)
-        ? TraceRuleMatchEvent_EntityContext_TraceContext.fromJSON(object.traceContext)
-        : isSet(object.trace_context)
-        ? TraceRuleMatchEvent_EntityContext_TraceContext.fromJSON(object.trace_context)
-        : undefined,
-    };
-  },
-
-  toJSON(message: TraceRuleMatchEvent_EntityContext): unknown {
-    const obj: any = {};
-    if (message.traceContext !== undefined) {
-      obj.traceContext = TraceRuleMatchEvent_EntityContext_TraceContext.toJSON(message.traceContext);
-    }
-    return obj;
-  },
-
-  create<I extends Exact<DeepPartial<TraceRuleMatchEvent_EntityContext>, I>>(
-    base?: I,
-  ): TraceRuleMatchEvent_EntityContext {
-    return TraceRuleMatchEvent_EntityContext.fromPartial(base ?? ({} as any));
-  },
-  fromPartial<I extends Exact<DeepPartial<TraceRuleMatchEvent_EntityContext>, I>>(
-    object: I,
-  ): TraceRuleMatchEvent_EntityContext {
-    const message = createBaseTraceRuleMatchEvent_EntityContext();
-    message.traceContext = (object.traceContext !== undefined && object.traceContext !== null)
-      ? TraceRuleMatchEvent_EntityContext_TraceContext.fromPartial(object.traceContext)
-      : undefined;
-    return message;
-  },
-};
-
-function createBaseTraceRuleMatchEvent_EntityContext_TraceContext(): TraceRuleMatchEvent_EntityContext_TraceContext {
-  return { traceId: "" };
-}
-
-export const TraceRuleMatchEvent_EntityContext_TraceContext: MessageFns<
-  TraceRuleMatchEvent_EntityContext_TraceContext
-> = {
-  encode(
-    message: TraceRuleMatchEvent_EntityContext_TraceContext,
-    writer: BinaryWriter = new BinaryWriter(),
-  ): BinaryWriter {
-    if (message.traceId !== "") {
-      writer.uint32(10).string(message.traceId);
-    }
-    return writer;
-  },
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
 
-  decode(input: BinaryReader | Uint8Array, length?: number): TraceRuleMatchEvent_EntityContext_TraceContext {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseTraceRuleMatchEvent_EntityContext_TraceContext();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
+          message.projectId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
             break;
           }
 
-          message.traceId = reader.string();
+          message.organizationId = reader.string();
           continue;
         }
-      }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.description = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.enabled = reader.int32() as any;
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.integrationIds.push(reader.string());
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+
+          message.condition = MetricRuleCondition.decode(reader, reader.uint32());
+          continue;
+        }
+        case 9: {
+          if (tag !== 72) {
+            break;
+          }
+
+          message.evaluationIntervalSeconds = longToNumber(reader.int64());
+          continue;
+        }
+        case 10: {
+          if (tag !== 80) {
+            break;
+          }
+
+          message.severity = reader.int32() as any;
+          continue;
+        }
+        case 11: {
+          if (tag !== 90) {
+            break;
+          }
+
+          message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 12: {
+          if (tag !== 98) {
+            break;
+          }
+
+          message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MetricRule {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      enabled: isSet(object.enabled) ? enabledStatusFromJSON(object.enabled) : 0,
+      integrationIds: globalThis.Array.isArray(object?.integrationIds)
+        ? object.integrationIds.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.integration_ids)
+        ? object.integration_ids.map((e: any) => globalThis.String(e))
+        : [],
+      condition: isSet(object.condition) ? MetricRuleCondition.fromJSON(object.condition) : undefined,
+      evaluationIntervalSeconds: isSet(object.evaluationIntervalSeconds)
+        ? globalThis.Number(object.evaluationIntervalSeconds)
+        : isSet(object.evaluation_interval_seconds)
+        ? globalThis.Number(object.evaluation_interval_seconds)
+        : 0,
+      severity: isSet(object.severity) ? severityFromJSON(object.severity) : 0,
+      createdAt: isSet(object.createdAt)
+        ? fromJsonTimestamp(object.createdAt)
+        : isSet(object.created_at)
+        ? fromJsonTimestamp(object.created_at)
+        : undefined,
+      updatedAt: isSet(object.updatedAt)
+        ? fromJsonTimestamp(object.updatedAt)
+        : isSet(object.updated_at)
+        ? fromJsonTimestamp(object.updated_at)
+        : undefined,
+    };
+  },
+
+  toJSON(message: MetricRule): unknown {
+    const obj: any = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.enabled !== 0) {
+      obj.enabled = enabledStatusToJSON(message.enabled);
+    }
+    if (message.integrationIds?.length) {
+      obj.integrationIds = message.integrationIds;
+    }
+    if (message.condition !== undefined) {
+      obj.condition = MetricRuleCondition.toJSON(message.condition);
+    }
+    if (message.evaluationIntervalSeconds !== 0) {
+      obj.evaluationIntervalSeconds = Math.round(message.evaluationIntervalSeconds);
+    }
+    if (message.severity !== 0) {
+      obj.severity = severityToJSON(message.severity);
+    }
+    if (message.createdAt !== undefined) {
+      obj.createdAt = message.createdAt.toISOString();
+    }
+    if (message.updatedAt !== undefined) {
+      obj.updatedAt = message.updatedAt.toISOString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MetricRule>, I>>(base?: I): MetricRule {
+    return MetricRule.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MetricRule>, I>>(object: I): MetricRule {
+    const message = createBaseMetricRule();
+    message.id = object.id ?? "";
+    message.projectId = object.projectId ?? "";
+    message.organizationId = object.organizationId ?? "";
+    message.name = object.name ?? "";
+    message.description = object.description ?? "";
+    message.enabled = object.enabled ?? 0;
+    message.integrationIds = object.integrationIds?.map((e) => e) || [];
+    message.condition = (object.condition !== undefined && object.condition !== null)
+      ? MetricRuleCondition.fromPartial(object.condition)
+      : undefined;
+    message.evaluationIntervalSeconds = object.evaluationIntervalSeconds ?? 0;
+    message.severity = object.severity ?? 0;
+    message.createdAt = object.createdAt ?? undefined;
+    message.updatedAt = object.updatedAt ?? undefined;
+    return message;
+  },
+};
+
+function createBaseMetricRuleCondition(): MetricRuleCondition {
+  return { expression: "", recoveryExpression: undefined };
+}
+
+export const MetricRuleCondition: MessageFns<MetricRuleCondition> = {
+  encode(message: MetricRuleCondition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.expression !== "") {
+      writer.uint32(10).string(message.expression);
+    }
+    if (message.recoveryExpression !== undefined) {
+      writer.uint32(18).string(message.recoveryExpression);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): MetricRuleCondition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMetricRuleCondition();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.expression = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.recoveryExpression = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MetricRuleCondition {
+    return {
+      expression: isSet(object.expression) ? globalThis.String(object.expression) : "",
+      recoveryExpression: isSet(object.recoveryExpression)
+        ? globalThis.String(object.recoveryExpression)
+        : isSet(object.recovery_expression)
+        ? globalThis.String(object.recovery_expression)
+        : undefined,
+    };
+  },
+
+  toJSON(message: MetricRuleCondition): unknown {
+    const obj: any = {};
+    if (message.expression !== "") {
+      obj.expression = message.expression;
+    }
+    if (message.recoveryExpression !== undefined) {
+      obj.recoveryExpression = message.recoveryExpression;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MetricRuleCondition>, I>>(base?: I): MetricRuleCondition {
+    return MetricRuleCondition.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MetricRuleCondition>, I>>(object: I): MetricRuleCondition {
+    const message = createBaseMetricRuleCondition();
+    message.expression = object.expression ?? "";
+    message.recoveryExpression = object.recoveryExpression ?? undefined;
+    return message;
+  },
+};
+
+function createBaseCreateMetricRuleRequest(): CreateMetricRuleRequest {
+  return {
+    projectId: "",
+    name: "",
+    description: "",
+    integrationIds: [],
+    condition: undefined,
+    evaluationIntervalSeconds: 0,
+    severity: 0,
+    organizationId: "",
+  };
+}
+
+export const CreateMetricRuleRequest: MessageFns<CreateMetricRuleRequest> = {
+  encode(message: CreateMetricRuleRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.projectId !== "") {
+      writer.uint32(10).string(message.projectId);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.description !== "") {
+      writer.uint32(26).string(message.description);
+    }
+    for (const v of message.integrationIds) {
+      writer.uint32(34).string(v!);
+    }
+    if (message.condition !== undefined) {
+      MetricRuleCondition.encode(message.condition, writer.uint32(42).fork()).join();
+    }
+    if (message.evaluationIntervalSeconds !== 0) {
+      writer.uint32(48).int64(message.evaluationIntervalSeconds);
+    }
+    if (message.severity !== 0) {
+      writer.uint32(56).int32(message.severity);
+    }
+    if (message.organizationId !== "") {
+      writer.uint32(66).string(message.organizationId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateMetricRuleRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCreateMetricRuleRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.projectId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.description = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.integrationIds.push(reader.string());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.condition = MetricRuleCondition.decode(reader, reader.uint32());
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.evaluationIntervalSeconds = longToNumber(reader.int64());
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+
+          message.severity = reader.int32() as any;
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+
+          message.organizationId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CreateMetricRuleRequest {
+    return {
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      integrationIds: globalThis.Array.isArray(object?.integrationIds)
+        ? object.integrationIds.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.integration_ids)
+        ? object.integration_ids.map((e: any) => globalThis.String(e))
+        : [],
+      condition: isSet(object.condition) ? MetricRuleCondition.fromJSON(object.condition) : undefined,
+      evaluationIntervalSeconds: isSet(object.evaluationIntervalSeconds)
+        ? globalThis.Number(object.evaluationIntervalSeconds)
+        : isSet(object.evaluation_interval_seconds)
+        ? globalThis.Number(object.evaluation_interval_seconds)
+        : 0,
+      severity: isSet(object.severity) ? severityFromJSON(object.severity) : 0,
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+    };
+  },
+
+  toJSON(message: CreateMetricRuleRequest): unknown {
+    const obj: any = {};
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.integrationIds?.length) {
+      obj.integrationIds = message.integrationIds;
+    }
+    if (message.condition !== undefined) {
+      obj.condition = MetricRuleCondition.toJSON(message.condition);
+    }
+    if (message.evaluationIntervalSeconds !== 0) {
+      obj.evaluationIntervalSeconds = Math.round(message.evaluationIntervalSeconds);
+    }
+    if (message.severity !== 0) {
+      obj.severity = severityToJSON(message.severity);
+    }
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CreateMetricRuleRequest>, I>>(base?: I): CreateMetricRuleRequest {
+    return CreateMetricRuleRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CreateMetricRuleRequest>, I>>(object: I): CreateMetricRuleRequest {
+    const message = createBaseCreateMetricRuleRequest();
+    message.projectId = object.projectId ?? "";
+    message.name = object.name ?? "";
+    message.description = object.description ?? "";
+    message.integrationIds = object.integrationIds?.map((e) => e) || [];
+    message.condition = (object.condition !== undefined && object.condition !== null)
+      ? MetricRuleCondition.fromPartial(object.condition)
+      : undefined;
+    message.evaluationIntervalSeconds = object.evaluationIntervalSeconds ?? 0;
+    message.severity = object.severity ?? 0;
+    message.organizationId = object.organizationId ?? "";
+    return message;
+  },
+};
+
+function createBaseCreateMetricRuleResponse(): CreateMetricRuleResponse {
+  return { status: undefined, metricRule: undefined };
+}
+
+export const CreateMetricRuleResponse: MessageFns<CreateMetricRuleResponse> = {
+  encode(message: CreateMetricRuleResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    if (message.metricRule !== undefined) {
+      MetricRule.encode(message.metricRule, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateMetricRuleResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCreateMetricRuleResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.status = ResponseStatus.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.metricRule = MetricRule.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CreateMetricRuleResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      metricRule: isSet(object.metricRule)
+        ? MetricRule.fromJSON(object.metricRule)
+        : isSet(object.metric_rule)
+        ? MetricRule.fromJSON(object.metric_rule)
+        : undefined,
+    };
+  },
+
+  toJSON(message: CreateMetricRuleResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.metricRule !== undefined) {
+      obj.metricRule = MetricRule.toJSON(message.metricRule);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CreateMetricRuleResponse>, I>>(base?: I): CreateMetricRuleResponse {
+    return CreateMetricRuleResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CreateMetricRuleResponse>, I>>(object: I): CreateMetricRuleResponse {
+    const message = createBaseCreateMetricRuleResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.metricRule = (object.metricRule !== undefined && object.metricRule !== null)
+      ? MetricRule.fromPartial(object.metricRule)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseGetMetricRuleRequest(): GetMetricRuleRequest {
+  return { projectId: "", metricRuleId: "", organizationId: "" };
+}
+
+export const GetMetricRuleRequest: MessageFns<GetMetricRuleRequest> = {
+  encode(message: GetMetricRuleRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.projectId !== "") {
+      writer.uint32(10).string(message.projectId);
+    }
+    if (message.metricRuleId !== "") {
+      writer.uint32(18).string(message.metricRuleId);
+    }
+    if (message.organizationId !== "") {
+      writer.uint32(26).string(message.organizationId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetMetricRuleRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetMetricRuleRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.projectId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.metricRuleId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.organizationId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetMetricRuleRequest {
+    return {
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      metricRuleId: isSet(object.metricRuleId)
+        ? globalThis.String(object.metricRuleId)
+        : isSet(object.metric_rule_id)
+        ? globalThis.String(object.metric_rule_id)
+        : "",
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+    };
+  },
+
+  toJSON(message: GetMetricRuleRequest): unknown {
+    const obj: any = {};
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.metricRuleId !== "") {
+      obj.metricRuleId = message.metricRuleId;
+    }
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetMetricRuleRequest>, I>>(base?: I): GetMetricRuleRequest {
+    return GetMetricRuleRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetMetricRuleRequest>, I>>(object: I): GetMetricRuleRequest {
+    const message = createBaseGetMetricRuleRequest();
+    message.projectId = object.projectId ?? "";
+    message.metricRuleId = object.metricRuleId ?? "";
+    message.organizationId = object.organizationId ?? "";
+    return message;
+  },
+};
+
+function createBaseGetMetricRuleResponse(): GetMetricRuleResponse {
+  return { status: undefined, metricRule: undefined };
+}
+
+export const GetMetricRuleResponse: MessageFns<GetMetricRuleResponse> = {
+  encode(message: GetMetricRuleResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    if (message.metricRule !== undefined) {
+      MetricRule.encode(message.metricRule, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetMetricRuleResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetMetricRuleResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.status = ResponseStatus.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.metricRule = MetricRule.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetMetricRuleResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      metricRule: isSet(object.metricRule)
+        ? MetricRule.fromJSON(object.metricRule)
+        : isSet(object.metric_rule)
+        ? MetricRule.fromJSON(object.metric_rule)
+        : undefined,
+    };
+  },
+
+  toJSON(message: GetMetricRuleResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.metricRule !== undefined) {
+      obj.metricRule = MetricRule.toJSON(message.metricRule);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetMetricRuleResponse>, I>>(base?: I): GetMetricRuleResponse {
+    return GetMetricRuleResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetMetricRuleResponse>, I>>(object: I): GetMetricRuleResponse {
+    const message = createBaseGetMetricRuleResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.metricRule = (object.metricRule !== undefined && object.metricRule !== null)
+      ? MetricRule.fromPartial(object.metricRule)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseListMetricRulesRequest(): ListMetricRulesRequest {
+  return { organizationId: "", organizationIdFilter: undefined, projectIdFilter: undefined };
+}
+
+export const ListMetricRulesRequest: MessageFns<ListMetricRulesRequest> = {
+  encode(message: ListMetricRulesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.organizationId !== "") {
+      writer.uint32(10).string(message.organizationId);
+    }
+    if (message.organizationIdFilter !== undefined) {
+      writer.uint32(18).string(message.organizationIdFilter);
+    }
+    if (message.projectIdFilter !== undefined) {
+      writer.uint32(26).string(message.projectIdFilter);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ListMetricRulesRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListMetricRulesRequest();
+    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.organizationIdFilter = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.projectIdFilter = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ListMetricRulesRequest {
+    return {
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+      organizationIdFilter: isSet(object.organizationIdFilter)
+        ? globalThis.String(object.organizationIdFilter)
+        : isSet(object.organization_id_filter)
+        ? globalThis.String(object.organization_id_filter)
+        : undefined,
+      projectIdFilter: isSet(object.projectIdFilter)
+        ? globalThis.String(object.projectIdFilter)
+        : isSet(object.project_id_filter)
+        ? globalThis.String(object.project_id_filter)
+        : undefined,
+    };
+  },
+
+  toJSON(message: ListMetricRulesRequest): unknown {
+    const obj: any = {};
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.organizationIdFilter !== undefined) {
+      obj.organizationIdFilter = message.organizationIdFilter;
+    }
+    if (message.projectIdFilter !== undefined) {
+      obj.projectIdFilter = message.projectIdFilter;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ListMetricRulesRequest>, I>>(base?: I): ListMetricRulesRequest {
+    return ListMetricRulesRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ListMetricRulesRequest>, I>>(object: I): ListMetricRulesRequest {
+    const message = createBaseListMetricRulesRequest();
+    message.organizationId = object.organizationId ?? "";
+    message.organizationIdFilter = object.organizationIdFilter ?? undefined;
+    message.projectIdFilter = object.projectIdFilter ?? undefined;
+    return message;
+  },
+};
+
+function createBaseListMetricRulesResponse(): ListMetricRulesResponse {
+  return { status: undefined, metricRules: [] };
+}
+
+export const ListMetricRulesResponse: MessageFns<ListMetricRulesResponse> = {
+  encode(message: ListMetricRulesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    for (const v of message.metricRules) {
+      MetricRule.encode(v!, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ListMetricRulesResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListMetricRulesResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.status = ResponseStatus.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.metricRules.push(MetricRule.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ListMetricRulesResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      metricRules: globalThis.Array.isArray(object?.metricRules)
+        ? object.metricRules.map((e: any) => MetricRule.fromJSON(e))
+        : globalThis.Array.isArray(object?.metric_rules)
+        ? object.metric_rules.map((e: any) => MetricRule.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: ListMetricRulesResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.metricRules?.length) {
+      obj.metricRules = message.metricRules.map((e) => MetricRule.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ListMetricRulesResponse>, I>>(base?: I): ListMetricRulesResponse {
+    return ListMetricRulesResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ListMetricRulesResponse>, I>>(object: I): ListMetricRulesResponse {
+    const message = createBaseListMetricRulesResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.metricRules = object.metricRules?.map((e) => MetricRule.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseUpdateMetricRuleRequest(): UpdateMetricRuleRequest {
+  return { projectId: "", metricRuleId: "", updates: undefined, organizationId: "" };
+}
+
+export const UpdateMetricRuleRequest: MessageFns<UpdateMetricRuleRequest> = {
+  encode(message: UpdateMetricRuleRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.projectId !== "") {
+      writer.uint32(10).string(message.projectId);
+    }
+    if (message.metricRuleId !== "") {
+      writer.uint32(18).string(message.metricRuleId);
+    }
+    if (message.updates !== undefined) {
+      UpdateMetricRuleRequest_MetricRuleUpdates.encode(message.updates, writer.uint32(26).fork()).join();
+    }
+    if (message.organizationId !== "") {
+      writer.uint32(34).string(message.organizationId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateMetricRuleRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateMetricRuleRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.projectId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.metricRuleId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.updates = UpdateMetricRuleRequest_MetricRuleUpdates.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.organizationId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): UpdateMetricRuleRequest {
+    return {
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      metricRuleId: isSet(object.metricRuleId)
+        ? globalThis.String(object.metricRuleId)
+        : isSet(object.metric_rule_id)
+        ? globalThis.String(object.metric_rule_id)
+        : "",
+      updates: isSet(object.updates) ? UpdateMetricRuleRequest_MetricRuleUpdates.fromJSON(object.updates) : undefined,
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+    };
+  },
+
+  toJSON(message: UpdateMetricRuleRequest): unknown {
+    const obj: any = {};
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.metricRuleId !== "") {
+      obj.metricRuleId = message.metricRuleId;
+    }
+    if (message.updates !== undefined) {
+      obj.updates = UpdateMetricRuleRequest_MetricRuleUpdates.toJSON(message.updates);
+    }
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateMetricRuleRequest>, I>>(base?: I): UpdateMetricRuleRequest {
+    return UpdateMetricRuleRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateMetricRuleRequest>, I>>(object: I): UpdateMetricRuleRequest {
+    const message = createBaseUpdateMetricRuleRequest();
+    message.projectId = object.projectId ?? "";
+    message.metricRuleId = object.metricRuleId ?? "";
+    message.updates = (object.updates !== undefined && object.updates !== null)
+      ? UpdateMetricRuleRequest_MetricRuleUpdates.fromPartial(object.updates)
+      : undefined;
+    message.organizationId = object.organizationId ?? "";
+    return message;
+  },
+};
+
+function createBaseUpdateMetricRuleRequest_Condition(): UpdateMetricRuleRequest_Condition {
+  return { condition: undefined };
+}
+
+export const UpdateMetricRuleRequest_Condition: MessageFns<UpdateMetricRuleRequest_Condition> = {
+  encode(message: UpdateMetricRuleRequest_Condition, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.condition !== undefined) {
+      MetricRuleCondition.encode(message.condition, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateMetricRuleRequest_Condition {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateMetricRuleRequest_Condition();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.condition = MetricRuleCondition.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): UpdateMetricRuleRequest_Condition {
+    return { condition: isSet(object.condition) ? MetricRuleCondition.fromJSON(object.condition) : undefined };
+  },
+
+  toJSON(message: UpdateMetricRuleRequest_Condition): unknown {
+    const obj: any = {};
+    if (message.condition !== undefined) {
+      obj.condition = MetricRuleCondition.toJSON(message.condition);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateMetricRuleRequest_Condition>, I>>(
+    base?: I,
+  ): UpdateMetricRuleRequest_Condition {
+    return UpdateMetricRuleRequest_Condition.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateMetricRuleRequest_Condition>, I>>(
+    object: I,
+  ): UpdateMetricRuleRequest_Condition {
+    const message = createBaseUpdateMetricRuleRequest_Condition();
+    message.condition = (object.condition !== undefined && object.condition !== null)
+      ? MetricRuleCondition.fromPartial(object.condition)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseUpdateMetricRuleRequest_IntegrationIds(): UpdateMetricRuleRequest_IntegrationIds {
+  return { ids: [] };
+}
+
+export const UpdateMetricRuleRequest_IntegrationIds: MessageFns<UpdateMetricRuleRequest_IntegrationIds> = {
+  encode(message: UpdateMetricRuleRequest_IntegrationIds, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.ids) {
+      writer.uint32(10).string(v!);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateMetricRuleRequest_IntegrationIds {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateMetricRuleRequest_IntegrationIds();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.ids.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): UpdateMetricRuleRequest_IntegrationIds {
+    return { ids: globalThis.Array.isArray(object?.ids) ? object.ids.map((e: any) => globalThis.String(e)) : [] };
+  },
+
+  toJSON(message: UpdateMetricRuleRequest_IntegrationIds): unknown {
+    const obj: any = {};
+    if (message.ids?.length) {
+      obj.ids = message.ids;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateMetricRuleRequest_IntegrationIds>, I>>(
+    base?: I,
+  ): UpdateMetricRuleRequest_IntegrationIds {
+    return UpdateMetricRuleRequest_IntegrationIds.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateMetricRuleRequest_IntegrationIds>, I>>(
+    object: I,
+  ): UpdateMetricRuleRequest_IntegrationIds {
+    const message = createBaseUpdateMetricRuleRequest_IntegrationIds();
+    message.ids = object.ids?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseUpdateMetricRuleRequest_MetricRuleUpdates(): UpdateMetricRuleRequest_MetricRuleUpdates {
+  return {
+    name: undefined,
+    description: undefined,
+    enabled: undefined,
+    evaluationIntervalSeconds: undefined,
+    severity: undefined,
+    integrationIds: undefined,
+    condition: undefined,
+  };
+}
+
+export const UpdateMetricRuleRequest_MetricRuleUpdates: MessageFns<UpdateMetricRuleRequest_MetricRuleUpdates> = {
+  encode(message: UpdateMetricRuleRequest_MetricRuleUpdates, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.name !== undefined) {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.description !== undefined) {
+      writer.uint32(18).string(message.description);
+    }
+    if (message.enabled !== undefined) {
+      writer.uint32(24).int32(message.enabled);
+    }
+    if (message.evaluationIntervalSeconds !== undefined) {
+      writer.uint32(32).int64(message.evaluationIntervalSeconds);
+    }
+    if (message.severity !== undefined) {
+      writer.uint32(40).int32(message.severity);
+    }
+    if (message.integrationIds !== undefined) {
+      UpdateMetricRuleRequest_IntegrationIds.encode(message.integrationIds, writer.uint32(50).fork()).join();
+    }
+    if (message.condition !== undefined) {
+      UpdateMetricRuleRequest_Condition.encode(message.condition, writer.uint32(58).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateMetricRuleRequest_MetricRuleUpdates {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateMetricRuleRequest_MetricRuleUpdates();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.description = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.enabled = reader.int32() as any;
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.evaluationIntervalSeconds = longToNumber(reader.int64());
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.severity = reader.int32() as any;
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.integrationIds = UpdateMetricRuleRequest_IntegrationIds.decode(reader, reader.uint32());
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.condition = UpdateMetricRuleRequest_Condition.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): UpdateMetricRuleRequest_MetricRuleUpdates {
+    return {
+      name: isSet(object.name) ? globalThis.String(object.name) : undefined,
+      description: isSet(object.description) ? globalThis.String(object.description) : undefined,
+      enabled: isSet(object.enabled) ? enabledStatusFromJSON(object.enabled) : undefined,
+      evaluationIntervalSeconds: isSet(object.evaluationIntervalSeconds)
+        ? globalThis.Number(object.evaluationIntervalSeconds)
+        : isSet(object.evaluation_interval_seconds)
+        ? globalThis.Number(object.evaluation_interval_seconds)
+        : undefined,
+      severity: isSet(object.severity) ? severityFromJSON(object.severity) : undefined,
+      integrationIds: isSet(object.integrationIds)
+        ? UpdateMetricRuleRequest_IntegrationIds.fromJSON(object.integrationIds)
+        : isSet(object.integration_ids)
+        ? UpdateMetricRuleRequest_IntegrationIds.fromJSON(object.integration_ids)
+        : undefined,
+      condition: isSet(object.condition) ? UpdateMetricRuleRequest_Condition.fromJSON(object.condition) : undefined,
+    };
+  },
+
+  toJSON(message: UpdateMetricRuleRequest_MetricRuleUpdates): unknown {
+    const obj: any = {};
+    if (message.name !== undefined) {
+      obj.name = message.name;
+    }
+    if (message.description !== undefined) {
+      obj.description = message.description;
+    }
+    if (message.enabled !== undefined) {
+      obj.enabled = enabledStatusToJSON(message.enabled);
+    }
+    if (message.evaluationIntervalSeconds !== undefined) {
+      obj.evaluationIntervalSeconds = Math.round(message.evaluationIntervalSeconds);
+    }
+    if (message.severity !== undefined) {
+      obj.severity = severityToJSON(message.severity);
+    }
+    if (message.integrationIds !== undefined) {
+      obj.integrationIds = UpdateMetricRuleRequest_IntegrationIds.toJSON(message.integrationIds);
+    }
+    if (message.condition !== undefined) {
+      obj.condition = UpdateMetricRuleRequest_Condition.toJSON(message.condition);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateMetricRuleRequest_MetricRuleUpdates>, I>>(
+    base?: I,
+  ): UpdateMetricRuleRequest_MetricRuleUpdates {
+    return UpdateMetricRuleRequest_MetricRuleUpdates.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateMetricRuleRequest_MetricRuleUpdates>, I>>(
+    object: I,
+  ): UpdateMetricRuleRequest_MetricRuleUpdates {
+    const message = createBaseUpdateMetricRuleRequest_MetricRuleUpdates();
+    message.name = object.name ?? undefined;
+    message.description = object.description ?? undefined;
+    message.enabled = object.enabled ?? undefined;
+    message.evaluationIntervalSeconds = object.evaluationIntervalSeconds ?? undefined;
+    message.severity = object.severity ?? undefined;
+    message.integrationIds = (object.integrationIds !== undefined && object.integrationIds !== null)
+      ? UpdateMetricRuleRequest_IntegrationIds.fromPartial(object.integrationIds)
+      : undefined;
+    message.condition = (object.condition !== undefined && object.condition !== null)
+      ? UpdateMetricRuleRequest_Condition.fromPartial(object.condition)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseUpdateMetricRuleResponse(): UpdateMetricRuleResponse {
+  return { status: undefined, metricRule: undefined };
+}
+
+export const UpdateMetricRuleResponse: MessageFns<UpdateMetricRuleResponse> = {
+  encode(message: UpdateMetricRuleResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    if (message.metricRule !== undefined) {
+      MetricRule.encode(message.metricRule, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateMetricRuleResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateMetricRuleResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.status = ResponseStatus.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.metricRule = MetricRule.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): UpdateMetricRuleResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      metricRule: isSet(object.metricRule)
+        ? MetricRule.fromJSON(object.metricRule)
+        : isSet(object.metric_rule)
+        ? MetricRule.fromJSON(object.metric_rule)
+        : undefined,
+    };
+  },
+
+  toJSON(message: UpdateMetricRuleResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.metricRule !== undefined) {
+      obj.metricRule = MetricRule.toJSON(message.metricRule);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateMetricRuleResponse>, I>>(base?: I): UpdateMetricRuleResponse {
+    return UpdateMetricRuleResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateMetricRuleResponse>, I>>(object: I): UpdateMetricRuleResponse {
+    const message = createBaseUpdateMetricRuleResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.metricRule = (object.metricRule !== undefined && object.metricRule !== null)
+      ? MetricRule.fromPartial(object.metricRule)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseDeleteMetricRuleRequest(): DeleteMetricRuleRequest {
+  return { projectId: "", metricRuleId: "", organizationId: "" };
+}
+
+export const DeleteMetricRuleRequest: MessageFns<DeleteMetricRuleRequest> = {
+  encode(message: DeleteMetricRuleRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.projectId !== "") {
+      writer.uint32(10).string(message.projectId);
+    }
+    if (message.metricRuleId !== "") {
+      writer.uint32(18).string(message.metricRuleId);
+    }
+    if (message.organizationId !== "") {
+      writer.uint32(26).string(message.organizationId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteMetricRuleRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDeleteMetricRuleRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.projectId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.metricRuleId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.organizationId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DeleteMetricRuleRequest {
+    return {
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      metricRuleId: isSet(object.metricRuleId)
+        ? globalThis.String(object.metricRuleId)
+        : isSet(object.metric_rule_id)
+        ? globalThis.String(object.metric_rule_id)
+        : "",
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+    };
+  },
+
+  toJSON(message: DeleteMetricRuleRequest): unknown {
+    const obj: any = {};
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.metricRuleId !== "") {
+      obj.metricRuleId = message.metricRuleId;
+    }
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DeleteMetricRuleRequest>, I>>(base?: I): DeleteMetricRuleRequest {
+    return DeleteMetricRuleRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DeleteMetricRuleRequest>, I>>(object: I): DeleteMetricRuleRequest {
+    const message = createBaseDeleteMetricRuleRequest();
+    message.projectId = object.projectId ?? "";
+    message.metricRuleId = object.metricRuleId ?? "";
+    message.organizationId = object.organizationId ?? "";
+    return message;
+  },
+};
+
+function createBaseDeleteMetricRuleResponse(): DeleteMetricRuleResponse {
+  return { status: undefined };
+}
+
+export const DeleteMetricRuleResponse: MessageFns<DeleteMetricRuleResponse> = {
+  encode(message: DeleteMetricRuleResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteMetricRuleResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDeleteMetricRuleResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.status = ResponseStatus.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DeleteMetricRuleResponse {
+    return { status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined };
+  },
+
+  toJSON(message: DeleteMetricRuleResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DeleteMetricRuleResponse>, I>>(base?: I): DeleteMetricRuleResponse {
+    return DeleteMetricRuleResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DeleteMetricRuleResponse>, I>>(object: I): DeleteMetricRuleResponse {
+    const message = createBaseDeleteMetricRuleResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    return message;
+  },
+};
+
+function createBasePreviewMetricRuleRequest(): PreviewMetricRuleRequest {
+  return { projectId: "", expression: "", organizationId: "" };
+}
+
+export const PreviewMetricRuleRequest: MessageFns<PreviewMetricRuleRequest> = {
+  encode(message: PreviewMetricRuleRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.projectId !== "") {
+      writer.uint32(10).string(message.projectId);
+    }
+    if (message.expression !== "") {
+      writer.uint32(18).string(message.expression);
+    }
+    if (message.organizationId !== "") {
+      writer.uint32(26).string(message.organizationId);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): PreviewMetricRuleRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePreviewMetricRuleRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.projectId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.expression = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.organizationId = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PreviewMetricRuleRequest {
+    return {
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      expression: isSet(object.expression) ? globalThis.String(object.expression) : "",
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+    };
+  },
+
+  toJSON(message: PreviewMetricRuleRequest): unknown {
+    const obj: any = {};
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.expression !== "") {
+      obj.expression = message.expression;
+    }
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PreviewMetricRuleRequest>, I>>(base?: I): PreviewMetricRuleRequest {
+    return PreviewMetricRuleRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<PreviewMetricRuleRequest>, I>>(object: I): PreviewMetricRuleRequest {
+    const message = createBasePreviewMetricRuleRequest();
+    message.projectId = object.projectId ?? "";
+    message.expression = object.expression ?? "";
+    message.organizationId = object.organizationId ?? "";
+    return message;
+  },
+};
+
+function createBasePreviewMetricRuleResponse(): PreviewMetricRuleResponse {
+  return { status: undefined, value: undefined, wouldFire: false, state: "" };
+}
+
+export const PreviewMetricRuleResponse: MessageFns<PreviewMetricRuleResponse> = {
+  encode(message: PreviewMetricRuleResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    if (message.value !== undefined) {
+      writer.uint32(17).double(message.value);
+    }
+    if (message.wouldFire !== false) {
+      writer.uint32(24).bool(message.wouldFire);
+    }
+    if (message.state !== "") {
+      writer.uint32(34).string(message.state);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): PreviewMetricRuleResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePreviewMetricRuleResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.status = ResponseStatus.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 17) {
+            break;
+          }
+
+          message.value = reader.double();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.wouldFire = reader.bool();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.state = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PreviewMetricRuleResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      value: isSet(object.value) ? globalThis.Number(object.value) : undefined,
+      wouldFire: isSet(object.wouldFire)
+        ? globalThis.Boolean(object.wouldFire)
+        : isSet(object.would_fire)
+        ? globalThis.Boolean(object.would_fire)
+        : false,
+      state: isSet(object.state) ? globalThis.String(object.state) : "",
+    };
+  },
+
+  toJSON(message: PreviewMetricRuleResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.value !== undefined) {
+      obj.value = message.value;
+    }
+    if (message.wouldFire !== false) {
+      obj.wouldFire = message.wouldFire;
+    }
+    if (message.state !== "") {
+      obj.state = message.state;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<PreviewMetricRuleResponse>, I>>(base?: I): PreviewMetricRuleResponse {
+    return PreviewMetricRuleResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<PreviewMetricRuleResponse>, I>>(object: I): PreviewMetricRuleResponse {
+    const message = createBasePreviewMetricRuleResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.value = object.value ?? undefined;
+    message.wouldFire = object.wouldFire ?? false;
+    message.state = object.state ?? "";
+    return message;
+  },
+};
+
+function createBaseStreamMetricRuleActivityRequest(): StreamMetricRuleActivityRequest {
+  return { projectId: "", organizationId: "", limit: 0 };
+}
+
+export const StreamMetricRuleActivityRequest: MessageFns<StreamMetricRuleActivityRequest> = {
+  encode(message: StreamMetricRuleActivityRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.projectId !== "") {
+      writer.uint32(10).string(message.projectId);
+    }
+    if (message.organizationId !== "") {
+      writer.uint32(18).string(message.organizationId);
+    }
+    if (message.limit !== 0) {
+      writer.uint32(24).int32(message.limit);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): StreamMetricRuleActivityRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseStreamMetricRuleActivityRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.projectId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.organizationId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.limit = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): StreamMetricRuleActivityRequest {
+    return {
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+      limit: isSet(object.limit) ? globalThis.Number(object.limit) : 0,
+    };
+  },
+
+  toJSON(message: StreamMetricRuleActivityRequest): unknown {
+    const obj: any = {};
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.limit !== 0) {
+      obj.limit = Math.round(message.limit);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<StreamMetricRuleActivityRequest>, I>>(base?: I): StreamMetricRuleActivityRequest {
+    return StreamMetricRuleActivityRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<StreamMetricRuleActivityRequest>, I>>(
+    object: I,
+  ): StreamMetricRuleActivityRequest {
+    const message = createBaseStreamMetricRuleActivityRequest();
+    message.projectId = object.projectId ?? "";
+    message.organizationId = object.organizationId ?? "";
+    message.limit = object.limit ?? 0;
+    return message;
+  },
+};
+
+function createBaseMetricRuleActivityEnvelope(): MetricRuleActivityEnvelope {
+  return { snapshot: undefined, update: undefined };
+}
+
+export const MetricRuleActivityEnvelope: MessageFns<MetricRuleActivityEnvelope> = {
+  encode(message: MetricRuleActivityEnvelope, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.snapshot !== undefined) {
+      MetricRuleActivitySnapshot.encode(message.snapshot, writer.uint32(10).fork()).join();
+    }
+    if (message.update !== undefined) {
+      MetricRuleActivityEvent.encode(message.update, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): MetricRuleActivityEnvelope {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMetricRuleActivityEnvelope();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.snapshot = MetricRuleActivitySnapshot.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.update = MetricRuleActivityEvent.decode(reader, reader.uint32());
+          continue;
+        }
+      }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
@@ -2698,34 +4851,319 @@ export const TraceRuleMatchEvent_EntityContext_TraceContext: MessageFns<
     return message;
   },
 
-  fromJSON(object: any): TraceRuleMatchEvent_EntityContext_TraceContext {
+  fromJSON(object: any): MetricRuleActivityEnvelope {
     return {
-      traceId: isSet(object.traceId)
-        ? globalThis.String(object.traceId)
-        : isSet(object.trace_id)
-        ? globalThis.String(object.trace_id)
+      snapshot: isSet(object.snapshot) ? MetricRuleActivitySnapshot.fromJSON(object.snapshot) : undefined,
+      update: isSet(object.update) ? MetricRuleActivityEvent.fromJSON(object.update) : undefined,
+    };
+  },
+
+  toJSON(message: MetricRuleActivityEnvelope): unknown {
+    const obj: any = {};
+    if (message.snapshot !== undefined) {
+      obj.snapshot = MetricRuleActivitySnapshot.toJSON(message.snapshot);
+    }
+    if (message.update !== undefined) {
+      obj.update = MetricRuleActivityEvent.toJSON(message.update);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MetricRuleActivityEnvelope>, I>>(base?: I): MetricRuleActivityEnvelope {
+    return MetricRuleActivityEnvelope.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MetricRuleActivityEnvelope>, I>>(object: I): MetricRuleActivityEnvelope {
+    const message = createBaseMetricRuleActivityEnvelope();
+    message.snapshot = (object.snapshot !== undefined && object.snapshot !== null)
+      ? MetricRuleActivitySnapshot.fromPartial(object.snapshot)
+      : undefined;
+    message.update = (object.update !== undefined && object.update !== null)
+      ? MetricRuleActivityEvent.fromPartial(object.update)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseMetricRuleActivitySnapshot(): MetricRuleActivitySnapshot {
+  return { activities: [] };
+}
+
+export const MetricRuleActivitySnapshot: MessageFns<MetricRuleActivitySnapshot> = {
+  encode(message: MetricRuleActivitySnapshot, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.activities) {
+      MetricRuleActivityEvent.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): MetricRuleActivitySnapshot {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMetricRuleActivitySnapshot();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.activities.push(MetricRuleActivityEvent.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MetricRuleActivitySnapshot {
+    return {
+      activities: globalThis.Array.isArray(object?.activities)
+        ? object.activities.map((e: any) => MetricRuleActivityEvent.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: MetricRuleActivitySnapshot): unknown {
+    const obj: any = {};
+    if (message.activities?.length) {
+      obj.activities = message.activities.map((e) => MetricRuleActivityEvent.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<MetricRuleActivitySnapshot>, I>>(base?: I): MetricRuleActivitySnapshot {
+    return MetricRuleActivitySnapshot.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MetricRuleActivitySnapshot>, I>>(object: I): MetricRuleActivitySnapshot {
+    const message = createBaseMetricRuleActivitySnapshot();
+    message.activities = object.activities?.map((e) => MetricRuleActivityEvent.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseMetricRuleActivityEvent(): MetricRuleActivityEvent {
+  return {
+    activityId: "",
+    ruleId: "",
+    ruleName: "",
+    type: 0,
+    incidentId: "",
+    expression: "",
+    observedValue: 0,
+    severity: 0,
+    occurredAt: undefined,
+  };
+}
+
+export const MetricRuleActivityEvent: MessageFns<MetricRuleActivityEvent> = {
+  encode(message: MetricRuleActivityEvent, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.activityId !== "") {
+      writer.uint32(10).string(message.activityId);
+    }
+    if (message.ruleId !== "") {
+      writer.uint32(18).string(message.ruleId);
+    }
+    if (message.ruleName !== "") {
+      writer.uint32(26).string(message.ruleName);
+    }
+    if (message.type !== 0) {
+      writer.uint32(32).int32(message.type);
+    }
+    if (message.incidentId !== "") {
+      writer.uint32(42).string(message.incidentId);
+    }
+    if (message.expression !== "") {
+      writer.uint32(50).string(message.expression);
+    }
+    if (message.observedValue !== 0) {
+      writer.uint32(57).double(message.observedValue);
+    }
+    if (message.severity !== 0) {
+      writer.uint32(64).int32(message.severity);
+    }
+    if (message.occurredAt !== undefined) {
+      Timestamp.encode(toTimestamp(message.occurredAt), writer.uint32(74).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): MetricRuleActivityEvent {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMetricRuleActivityEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.activityId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.ruleId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.ruleName = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.type = reader.int32() as any;
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.incidentId = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.expression = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 57) {
+            break;
+          }
+
+          message.observedValue = reader.double();
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+
+          message.severity = reader.int32() as any;
+          continue;
+        }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+
+          message.occurredAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MetricRuleActivityEvent {
+    return {
+      activityId: isSet(object.activityId)
+        ? globalThis.String(object.activityId)
+        : isSet(object.activity_id)
+        ? globalThis.String(object.activity_id)
+        : "",
+      ruleId: isSet(object.ruleId)
+        ? globalThis.String(object.ruleId)
+        : isSet(object.rule_id)
+        ? globalThis.String(object.rule_id)
         : "",
+      ruleName: isSet(object.ruleName)
+        ? globalThis.String(object.ruleName)
+        : isSet(object.rule_name)
+        ? globalThis.String(object.rule_name)
+        : "",
+      type: isSet(object.type) ? metricActivityTypeFromJSON(object.type) : 0,
+      incidentId: isSet(object.incidentId)
+        ? globalThis.String(object.incidentId)
+        : isSet(object.incident_id)
+        ? globalThis.String(object.incident_id)
+        : "",
+      expression: isSet(object.expression) ? globalThis.String(object.expression) : "",
+      observedValue: isSet(object.observedValue)
+        ? globalThis.Number(object.observedValue)
+        : isSet(object.observed_value)
+        ? globalThis.Number(object.observed_value)
+        : 0,
+      severity: isSet(object.severity) ? severityFromJSON(object.severity) : 0,
+      occurredAt: isSet(object.occurredAt)
+        ? fromJsonTimestamp(object.occurredAt)
+        : isSet(object.occurred_at)
+        ? fromJsonTimestamp(object.occurred_at)
+        : undefined,
     };
   },
 
-  toJSON(message: TraceRuleMatchEvent_EntityContext_TraceContext): unknown {
+  toJSON(message: MetricRuleActivityEvent): unknown {
     const obj: any = {};
-    if (message.traceId !== "") {
-      obj.traceId = message.traceId;
+    if (message.activityId !== "") {
+      obj.activityId = message.activityId;
+    }
+    if (message.ruleId !== "") {
+      obj.ruleId = message.ruleId;
+    }
+    if (message.ruleName !== "") {
+      obj.ruleName = message.ruleName;
+    }
+    if (message.type !== 0) {
+      obj.type = metricActivityTypeToJSON(message.type);
+    }
+    if (message.incidentId !== "") {
+      obj.incidentId = message.incidentId;
+    }
+    if (message.expression !== "") {
+      obj.expression = message.expression;
+    }
+    if (message.observedValue !== 0) {
+      obj.observedValue = message.observedValue;
+    }
+    if (message.severity !== 0) {
+      obj.severity = severityToJSON(message.severity);
+    }
+    if (message.occurredAt !== undefined) {
+      obj.occurredAt = message.occurredAt.toISOString();
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<TraceRuleMatchEvent_EntityContext_TraceContext>, I>>(
-    base?: I,
-  ): TraceRuleMatchEvent_EntityContext_TraceContext {
-    return TraceRuleMatchEvent_EntityContext_TraceContext.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<MetricRuleActivityEvent>, I>>(base?: I): MetricRuleActivityEvent {
+    return MetricRuleActivityEvent.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<TraceRuleMatchEvent_EntityContext_TraceContext>, I>>(
-    object: I,
-  ): TraceRuleMatchEvent_EntityContext_TraceContext {
-    const message = createBaseTraceRuleMatchEvent_EntityContext_TraceContext();
-    message.traceId = object.traceId ?? "";
+  fromPartial<I extends Exact<DeepPartial<MetricRuleActivityEvent>, I>>(object: I): MetricRuleActivityEvent {
+    const message = createBaseMetricRuleActivityEvent();
+    message.activityId = object.activityId ?? "";
+    message.ruleId = object.ruleId ?? "";
+    message.ruleName = object.ruleName ?? "";
+    message.type = object.type ?? 0;
+    message.incidentId = object.incidentId ?? "";
+    message.expression = object.expression ?? "";
+    message.observedValue = object.observedValue ?? 0;
+    message.severity = object.severity ?? 0;
+    message.occurredAt = object.occurredAt ?? undefined;
     return message;
   },
 };
@@ -2754,13 +5192,28 @@ export interface RuleGatewayService {
     metadata?: Metadata,
   ): Promise<ListTraceRuleSchemasResponse>;
   /**
-   * StreamTraceRuleMatches sends an initial snapshot of recent trace-rule
-   * matches followed by live updates as new matches occur.
+   * StreamTraceRuleActivity sends a snapshot of recent trace-rule matches
+   * followed by live matches.
+   */
+  StreamTraceRuleActivity(
+    request: StreamTraceRuleActivityRequest,
+    metadata?: Metadata,
+  ): Observable<TraceRuleActivityEnvelope>;
+  /** Metric rule operations (PromQL threshold alerting) */
+  CreateMetricRule(request: CreateMetricRuleRequest, metadata?: Metadata): Promise<CreateMetricRuleResponse>;
+  GetMetricRule(request: GetMetricRuleRequest, metadata?: Metadata): Promise<GetMetricRuleResponse>;
+  ListMetricRules(request: ListMetricRulesRequest, metadata?: Metadata): Promise<ListMetricRulesResponse>;
+  UpdateMetricRule(request: UpdateMetricRuleRequest, metadata?: Metadata): Promise<UpdateMetricRuleResponse>;
+  DeleteMetricRule(request: DeleteMetricRuleRequest, metadata?: Metadata): Promise<DeleteMetricRuleResponse>;
+  PreviewMetricRule(request: PreviewMetricRuleRequest, metadata?: Metadata): Promise<PreviewMetricRuleResponse>;
+  /**
+   * StreamMetricRuleActivity sends a snapshot of recent metric-rule firings and
+   * recoveries followed by live transitions.
    */
-  StreamTraceRuleMatches(
-    request: StreamTraceRuleMatchesRequest,
+  StreamMetricRuleActivity(
+    request: StreamMetricRuleActivityRequest,
     metadata?: Metadata,
-  ): Observable<TraceRuleMatchEnvelope>;
+  ): Observable<MetricRuleActivityEnvelope>;
 }
 
 export const RuleGatewayServiceServiceName = "gateway.web.v1.RuleGatewayService";
@@ -2777,7 +5230,14 @@ export class RuleGatewayServiceClientImpl implements RuleGatewayService {
     this.DeleteTraceRule = this.DeleteTraceRule.bind(this);
     this.StreamTraceRuleSimulation = this.StreamTraceRuleSimulation.bind(this);
     this.ListTraceRuleSchemas = this.ListTraceRuleSchemas.bind(this);
-    this.StreamTraceRuleMatches = this.StreamTraceRuleMatches.bind(this);
+    this.StreamTraceRuleActivity = this.StreamTraceRuleActivity.bind(this);
+    this.CreateMetricRule = this.CreateMetricRule.bind(this);
+    this.GetMetricRule = this.GetMetricRule.bind(this);
+    this.ListMetricRules = this.ListMetricRules.bind(this);
+    this.UpdateMetricRule = this.UpdateMetricRule.bind(this);
+    this.DeleteMetricRule = this.DeleteMetricRule.bind(this);
+    this.PreviewMetricRule = this.PreviewMetricRule.bind(this);
+    this.StreamMetricRuleActivity = this.StreamMetricRuleActivity.bind(this);
   }
   CreateTraceRule(request: CreateTraceRuleRequest, metadata?: Metadata): Promise<CreateTraceRuleResponse> {
     const data = CreateTraceRuleRequest.encode(request).finish();
@@ -2827,13 +5287,58 @@ export class RuleGatewayServiceClientImpl implements RuleGatewayService {
     return promise.then((data) => ListTraceRuleSchemasResponse.decode(new BinaryReader(data)));
   }
 
-  StreamTraceRuleMatches(
-    request: StreamTraceRuleMatchesRequest,
+  StreamTraceRuleActivity(
+    request: StreamTraceRuleActivityRequest,
+    metadata?: Metadata,
+  ): Observable<TraceRuleActivityEnvelope> {
+    const data = StreamTraceRuleActivityRequest.encode(request).finish();
+    const result = this.rpc.serverStreamingRequest(this.service, "StreamTraceRuleActivity", data, metadata);
+    return result.pipe(map((data) => TraceRuleActivityEnvelope.decode(new BinaryReader(data))));
+  }
+
+  CreateMetricRule(request: CreateMetricRuleRequest, metadata?: Metadata): Promise<CreateMetricRuleResponse> {
+    const data = CreateMetricRuleRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "CreateMetricRule", data, metadata);
+    return promise.then((data) => CreateMetricRuleResponse.decode(new BinaryReader(data)));
+  }
+
+  GetMetricRule(request: GetMetricRuleRequest, metadata?: Metadata): Promise<GetMetricRuleResponse> {
+    const data = GetMetricRuleRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetMetricRule", data, metadata);
+    return promise.then((data) => GetMetricRuleResponse.decode(new BinaryReader(data)));
+  }
+
+  ListMetricRules(request: ListMetricRulesRequest, metadata?: Metadata): Promise<ListMetricRulesResponse> {
+    const data = ListMetricRulesRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ListMetricRules", data, metadata);
+    return promise.then((data) => ListMetricRulesResponse.decode(new BinaryReader(data)));
+  }
+
+  UpdateMetricRule(request: UpdateMetricRuleRequest, metadata?: Metadata): Promise<UpdateMetricRuleResponse> {
+    const data = UpdateMetricRuleRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "UpdateMetricRule", data, metadata);
+    return promise.then((data) => UpdateMetricRuleResponse.decode(new BinaryReader(data)));
+  }
+
+  DeleteMetricRule(request: DeleteMetricRuleRequest, metadata?: Metadata): Promise<DeleteMetricRuleResponse> {
+    const data = DeleteMetricRuleRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "DeleteMetricRule", data, metadata);
+    return promise.then((data) => DeleteMetricRuleResponse.decode(new BinaryReader(data)));
+  }
+
+  PreviewMetricRule(request: PreviewMetricRuleRequest, metadata?: Metadata): Promise<PreviewMetricRuleResponse> {
+    const data = PreviewMetricRuleRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "PreviewMetricRule", data, metadata);
+    return promise.then((data) => PreviewMetricRuleResponse.decode(new BinaryReader(data)));
+  }
+
+  StreamMetricRuleActivity(
+    request: StreamMetricRuleActivityRequest,
     metadata?: Metadata,
-  ): Observable<TraceRuleMatchEnvelope> {
-    const data = StreamTraceRuleMatchesRequest.encode(request).finish();
-    const result = this.rpc.serverStreamingRequest(this.service, "StreamTraceRuleMatches", data, metadata);
-    return result.pipe(map((data) => TraceRuleMatchEnvelope.decode(new BinaryReader(data))));
+  ): Observable<MetricRuleActivityEnvelope> {
+    const data = StreamMetricRuleActivityRequest.encode(request).finish();
+    const result = this.rpc.serverStreamingRequest(this.service, "StreamMetricRuleActivity", data, metadata);
+    return result.pipe(map((data) => MetricRuleActivityEnvelope.decode(new BinaryReader(data))));
   }
 }
 
@@ -2893,6 +5398,17 @@ function fromJsonTimestamp(o: any): Date {
   }
 }
 
+function longToNumber(int64: { toString(): string }): number {
+  const num = globalThis.Number(int64.toString());
+  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+  }
+  return num;
+}
+
 function isSet(value: any): boolean {
   return value !== null && value !== undefined;
 }