@miradorlabs/web-grpc 2.18.0 → 2.20.0

package/proto/gateway/web/v1/{sla_gateway.ts → slo_gateway.ts}

@@ -2,7 +2,7 @@
 // versions:
 //   protoc-gen-ts_proto  v2.12.0
 //   protoc               v3.21.12
-// source: proto/gateway/web/v1/sla_gateway.proto
+// source: proto/gateway/web/v1/slo_gateway.proto
 
 /* eslint-disable */
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
@@ -12,283 +12,242 @@ import { ResponseStatus } from "../../common/v1/status";
 
 export const protobufPackage = "gateway.web.v1";
 
-export enum SlaComparator {
-  SLA_COMPARATOR_UNSPECIFIED = 0,
-  SLA_COMPARATOR_GREATER_THAN = 1,
-  SLA_COMPARATOR_GREATER_THAN_OR_EQUAL = 2,
-  SLA_COMPARATOR_LESS_THAN = 3,
-  SLA_COMPARATOR_LESS_THAN_OR_EQUAL = 4,
+export enum SloComparator {
+  SLO_COMPARATOR_UNSPECIFIED = 0,
+  SLO_COMPARATOR_GREATER_THAN = 1,
+  SLO_COMPARATOR_GREATER_THAN_OR_EQUAL = 2,
+  SLO_COMPARATOR_LESS_THAN = 3,
+  SLO_COMPARATOR_LESS_THAN_OR_EQUAL = 4,
   UNRECOGNIZED = -1,
 }
 
-export function slaComparatorFromJSON(object: any): SlaComparator {
+export function sloComparatorFromJSON(object: any): SloComparator {
   switch (object) {
     case 0:
-    case "SLA_COMPARATOR_UNSPECIFIED":
-      return SlaComparator.SLA_COMPARATOR_UNSPECIFIED;
+    case "SLO_COMPARATOR_UNSPECIFIED":
+      return SloComparator.SLO_COMPARATOR_UNSPECIFIED;
     case 1:
-    case "SLA_COMPARATOR_GREATER_THAN":
-      return SlaComparator.SLA_COMPARATOR_GREATER_THAN;
+    case "SLO_COMPARATOR_GREATER_THAN":
+      return SloComparator.SLO_COMPARATOR_GREATER_THAN;
     case 2:
-    case "SLA_COMPARATOR_GREATER_THAN_OR_EQUAL":
-      return SlaComparator.SLA_COMPARATOR_GREATER_THAN_OR_EQUAL;
+    case "SLO_COMPARATOR_GREATER_THAN_OR_EQUAL":
+      return SloComparator.SLO_COMPARATOR_GREATER_THAN_OR_EQUAL;
     case 3:
-    case "SLA_COMPARATOR_LESS_THAN":
-      return SlaComparator.SLA_COMPARATOR_LESS_THAN;
+    case "SLO_COMPARATOR_LESS_THAN":
+      return SloComparator.SLO_COMPARATOR_LESS_THAN;
     case 4:
-    case "SLA_COMPARATOR_LESS_THAN_OR_EQUAL":
-      return SlaComparator.SLA_COMPARATOR_LESS_THAN_OR_EQUAL;
+    case "SLO_COMPARATOR_LESS_THAN_OR_EQUAL":
+      return SloComparator.SLO_COMPARATOR_LESS_THAN_OR_EQUAL;
     case -1:
     case "UNRECOGNIZED":
     default:
-      return SlaComparator.UNRECOGNIZED;
+      return SloComparator.UNRECOGNIZED;
   }
 }
 
-export function slaComparatorToJSON(object: SlaComparator): string {
+export function sloComparatorToJSON(object: SloComparator): string {
   switch (object) {
-    case SlaComparator.SLA_COMPARATOR_UNSPECIFIED:
-      return "SLA_COMPARATOR_UNSPECIFIED";
-    case SlaComparator.SLA_COMPARATOR_GREATER_THAN:
-      return "SLA_COMPARATOR_GREATER_THAN";
-    case SlaComparator.SLA_COMPARATOR_GREATER_THAN_OR_EQUAL:
-      return "SLA_COMPARATOR_GREATER_THAN_OR_EQUAL";
-    case SlaComparator.SLA_COMPARATOR_LESS_THAN:
-      return "SLA_COMPARATOR_LESS_THAN";
-    case SlaComparator.SLA_COMPARATOR_LESS_THAN_OR_EQUAL:
-      return "SLA_COMPARATOR_LESS_THAN_OR_EQUAL";
-    case SlaComparator.UNRECOGNIZED:
+    case SloComparator.SLO_COMPARATOR_UNSPECIFIED:
+      return "SLO_COMPARATOR_UNSPECIFIED";
+    case SloComparator.SLO_COMPARATOR_GREATER_THAN:
+      return "SLO_COMPARATOR_GREATER_THAN";
+    case SloComparator.SLO_COMPARATOR_GREATER_THAN_OR_EQUAL:
+      return "SLO_COMPARATOR_GREATER_THAN_OR_EQUAL";
+    case SloComparator.SLO_COMPARATOR_LESS_THAN:
+      return "SLO_COMPARATOR_LESS_THAN";
+    case SloComparator.SLO_COMPARATOR_LESS_THAN_OR_EQUAL:
+      return "SLO_COMPARATOR_LESS_THAN_OR_EQUAL";
+    case SloComparator.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
   }
 }
 
-export enum SlaOccurrence {
-  SLA_OCCURRENCE_UNSPECIFIED = 0,
-  SLA_OCCURRENCE_EARLIEST = 1,
-  SLA_OCCURRENCE_LATEST = 2,
+export enum SloCorridorState {
+  SLO_CORRIDOR_STATE_UNSPECIFIED = 0,
+  SLO_CORRIDOR_STATE_OK = 1,
+  SLO_CORRIDOR_STATE_BREACHED = 2,
+  SLO_CORRIDOR_STATE_NO_DATA = 3,
   UNRECOGNIZED = -1,
 }
 
-export function slaOccurrenceFromJSON(object: any): SlaOccurrence {
+export function sloCorridorStateFromJSON(object: any): SloCorridorState {
   switch (object) {
     case 0:
-    case "SLA_OCCURRENCE_UNSPECIFIED":
-      return SlaOccurrence.SLA_OCCURRENCE_UNSPECIFIED;
+    case "SLO_CORRIDOR_STATE_UNSPECIFIED":
+      return SloCorridorState.SLO_CORRIDOR_STATE_UNSPECIFIED;
     case 1:
-    case "SLA_OCCURRENCE_EARLIEST":
-      return SlaOccurrence.SLA_OCCURRENCE_EARLIEST;
+    case "SLO_CORRIDOR_STATE_OK":
+      return SloCorridorState.SLO_CORRIDOR_STATE_OK;
     case 2:
-    case "SLA_OCCURRENCE_LATEST":
-      return SlaOccurrence.SLA_OCCURRENCE_LATEST;
-    case -1:
-    case "UNRECOGNIZED":
-    default:
-      return SlaOccurrence.UNRECOGNIZED;
-  }
-}
-
-export function slaOccurrenceToJSON(object: SlaOccurrence): string {
-  switch (object) {
-    case SlaOccurrence.SLA_OCCURRENCE_UNSPECIFIED:
-      return "SLA_OCCURRENCE_UNSPECIFIED";
-    case SlaOccurrence.SLA_OCCURRENCE_EARLIEST:
-      return "SLA_OCCURRENCE_EARLIEST";
-    case SlaOccurrence.SLA_OCCURRENCE_LATEST:
-      return "SLA_OCCURRENCE_LATEST";
-    case SlaOccurrence.UNRECOGNIZED:
-    default:
-      return "UNRECOGNIZED";
-  }
-}
-
-export enum SlaOutcomeStatus {
-  SLA_OUTCOME_STATUS_UNSPECIFIED = 0,
-  SLA_OUTCOME_STATUS_PASS = 1,
-  SLA_OUTCOME_STATUS_FAIL = 2,
-  SLA_OUTCOME_STATUS_NO_DATA = 3,
-  SLA_OUTCOME_STATUS_ERROR = 4,
-  UNRECOGNIZED = -1,
-}
-
-export function slaOutcomeStatusFromJSON(object: any): SlaOutcomeStatus {
-  switch (object) {
-    case 0:
-    case "SLA_OUTCOME_STATUS_UNSPECIFIED":
-      return SlaOutcomeStatus.SLA_OUTCOME_STATUS_UNSPECIFIED;
-    case 1:
-    case "SLA_OUTCOME_STATUS_PASS":
-      return SlaOutcomeStatus.SLA_OUTCOME_STATUS_PASS;
-    case 2:
-    case "SLA_OUTCOME_STATUS_FAIL":
-      return SlaOutcomeStatus.SLA_OUTCOME_STATUS_FAIL;
+    case "SLO_CORRIDOR_STATE_BREACHED":
+      return SloCorridorState.SLO_CORRIDOR_STATE_BREACHED;
     case 3:
-    case "SLA_OUTCOME_STATUS_NO_DATA":
-      return SlaOutcomeStatus.SLA_OUTCOME_STATUS_NO_DATA;
-    case 4:
-    case "SLA_OUTCOME_STATUS_ERROR":
-      return SlaOutcomeStatus.SLA_OUTCOME_STATUS_ERROR;
+    case "SLO_CORRIDOR_STATE_NO_DATA":
+      return SloCorridorState.SLO_CORRIDOR_STATE_NO_DATA;
     case -1:
     case "UNRECOGNIZED":
     default:
-      return SlaOutcomeStatus.UNRECOGNIZED;
+      return SloCorridorState.UNRECOGNIZED;
   }
 }
 
-export function slaOutcomeStatusToJSON(object: SlaOutcomeStatus): string {
+export function sloCorridorStateToJSON(object: SloCorridorState): string {
   switch (object) {
-    case SlaOutcomeStatus.SLA_OUTCOME_STATUS_UNSPECIFIED:
-      return "SLA_OUTCOME_STATUS_UNSPECIFIED";
-    case SlaOutcomeStatus.SLA_OUTCOME_STATUS_PASS:
-      return "SLA_OUTCOME_STATUS_PASS";
-    case SlaOutcomeStatus.SLA_OUTCOME_STATUS_FAIL:
-      return "SLA_OUTCOME_STATUS_FAIL";
-    case SlaOutcomeStatus.SLA_OUTCOME_STATUS_NO_DATA:
-      return "SLA_OUTCOME_STATUS_NO_DATA";
-    case SlaOutcomeStatus.SLA_OUTCOME_STATUS_ERROR:
-      return "SLA_OUTCOME_STATUS_ERROR";
-    case SlaOutcomeStatus.UNRECOGNIZED:
+    case SloCorridorState.SLO_CORRIDOR_STATE_UNSPECIFIED:
+      return "SLO_CORRIDOR_STATE_UNSPECIFIED";
+    case SloCorridorState.SLO_CORRIDOR_STATE_OK:
+      return "SLO_CORRIDOR_STATE_OK";
+    case SloCorridorState.SLO_CORRIDOR_STATE_BREACHED:
+      return "SLO_CORRIDOR_STATE_BREACHED";
+    case SloCorridorState.SLO_CORRIDOR_STATE_NO_DATA:
+      return "SLO_CORRIDOR_STATE_NO_DATA";
+    case SloCorridorState.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
   }
 }
 
-export interface Sla {
+export interface Slo {
   id: string;
   organizationId: string;
   projectId: string;
   name: string;
   description: string;
   enabled: boolean;
-  check: SlaCheck | undefined;
-  currentRevision: number;
-  /** Server-assigned and immutable: mirador.sla.<id>.diff — query it via MetricGatewayService. */
-  metricName: string;
+  objective: SloObjective | undefined;
   createdAt: Date | undefined;
   updatedAt: Date | undefined;
 }
 
-/** SlaCheck is the measurement: diff = side_a - side_b, compared against threshold. */
-export interface SlaCheck {
-  sideA: SlaAttributeRef | undefined;
-  sideB: SlaAttributeRef | undefined;
-  comparator: SlaComparator;
-  threshold: number;
-}
-
 /**
- * SlaAttributeRef addresses one numeric per-event trace attribute. Timestamps are
- * addressed as ordinary numeric attributes (epoch millis), so "B within N of A" is a
- * plain value diff — there is no separate latency mode.
+ * SloObjective is the measurement: over the rolling window, at least `target` of the
+ * eligible samples of `metric_name` (split into one row per `group_by` combination) must be
+ * "good". What counts as good is the SLI in the oneof.
  */
-export interface SlaAttributeRef {
-  attributeKey: string;
-  /** Optional: restrict the lookup to events with this name. */
-  eventName: string;
-  occurrence: SlaOccurrence;
+export interface SloObjective {
+  metricName: string;
+  groupBy: string[];
+  target: number;
+  windowSeconds: number;
+  gaugeThreshold?: GaugeThresholdSli | undefined;
 }
 
-export interface SlaOutcome {
-  slaId: string;
-  revision: number;
-  traceId: string;
-  terminalVersion: number;
-  outcome: SlaOutcomeStatus;
-  sideAValue?: number | undefined;
-  sideBValue?: number | undefined;
-  diff?: number | undefined;
-  reasonCode: string;
-  traceFinishedAt: Date | undefined;
-  evaluatedAt: Date | undefined;
+/** GaugeThresholdSli: a gauge sample is "good" when value <comparator> threshold. */
+export interface GaugeThresholdSli {
+  comparator: SloComparator;
+  threshold: number;
 }
 
-export interface CreateSlaRequest {
+export interface CreateSloRequest {
   organizationId: string;
   projectId: string;
   name: string;
   description: string;
   enabled: boolean;
-  check: SlaCheck | undefined;
+  objective: SloObjective | undefined;
 }
 
-export interface CreateSlaResponse {
+export interface CreateSloResponse {
   status: ResponseStatus | undefined;
-  sla: Sla | undefined;
+  slo: Slo | undefined;
 }
 
-export interface GetSlaRequest {
+export interface GetSloRequest {
   organizationId: string;
   projectId: string;
-  slaId: string;
+  sloId: string;
 }
 
-export interface GetSlaResponse {
+export interface GetSloResponse {
   status: ResponseStatus | undefined;
-  sla: Sla | undefined;
+  slo: Slo | undefined;
 }
 
-export interface ListSlasRequest {
+export interface ListSlosRequest {
   organizationId: string;
   projectId: string;
 }
 
-export interface ListSlasResponse {
+export interface ListSlosResponse {
   status: ResponseStatus | undefined;
-  slas: Sla[];
+  slos: Slo[];
 }
 
-export interface UpdateSlaRequest {
+export interface UpdateSloRequest {
   organizationId: string;
   projectId: string;
-  slaId: string;
-  updates: UpdateSlaRequest_SlaUpdates | undefined;
+  sloId: string;
+  updates: UpdateSloRequest_SloUpdates | undefined;
 }
 
-export interface UpdateSlaRequest_SlaUpdates {
+export interface UpdateSloRequest_SloUpdates {
   name?: string | undefined;
   description?: string | undefined;
   enabled?:
     | boolean
     | undefined;
-  /** If set, replaces the whole check. */
-  check: SlaCheck | undefined;
+  /** If set, replaces the whole objective. */
+  objective: SloObjective | undefined;
 }
 
-export interface UpdateSlaResponse {
+export interface UpdateSloResponse {
   status: ResponseStatus | undefined;
-  sla: Sla | undefined;
+  slo: Slo | undefined;
 }
 
-export interface DeleteSlaRequest {
+export interface DeleteSloRequest {
   organizationId: string;
   projectId: string;
-  slaId: string;
+  sloId: string;
 }
 
-export interface DeleteSlaResponse {
+export interface DeleteSloResponse {
   status: ResponseStatus | undefined;
 }
 
-export interface ListSlaOutcomesRequest {
+export interface GetSloStatusRequest {
   organizationId: string;
   projectId: string;
-  slaId: string;
-  startTime: Date | undefined;
-  endTime:
-    | Date
-    | undefined;
-  /** Unspecified returns every outcome status. */
-  outcome: SlaOutcomeStatus;
-  limit: number;
-  offset: number;
+  sloId: string;
+  /** evaluation_time: the instant the rolling window ends at. Unset = server now(). */
+  evaluationTime: Date | undefined;
 }
 
-export interface ListSlaOutcomesResponse {
+export interface GetSloStatusResponse {
   status: ResponseStatus | undefined;
-  outcomes: SlaOutcome[];
+  sloStatus: SloStatus | undefined;
+}
+
+/**
+ * SloStatus is one SLO's live compliance over its rolling window, one row per
+ * observed corridor. A disabled SLO returns no corridors (nothing is evaluated).
+ */
+export interface SloStatus {
+  sloId: string;
+  enabled: boolean;
+  windowSeconds: number;
+  windowStart: Date | undefined;
+  windowEnd: Date | undefined;
+  corridors: SloCorridorStatus[];
+}
+
+/**
+ * SloCorridorStatus is one group_by combination's compliance. group_values is
+ * parallel to the objective's group_by (empty for a project-wide SLO).
+ */
+export interface SloCorridorStatus {
+  groupValues: string[];
+  eligibleCount: number;
+  goodCount: number;
+  /** compliance: good/eligible in [0,1]; 0 and state NO_DATA when eligible_count is 0. */
+  compliance: number;
+  /** budget_remaining: 1 - (1 - compliance)/(1 - target); may be negative when overspent. */
+  budgetRemaining: number;
+  state: SloCorridorState;
 }
 
-function createBaseSla(): Sla {
+function createBaseSlo(): Slo {
   return {
     id: "",
     organizationId: "",
@@ -296,16 +255,14 @@ function createBaseSla(): Sla {
     name: "",
     description: "",
     enabled: false,
-    check: undefined,
-    currentRevision: 0,
-    metricName: "",
+    objective: undefined,
     createdAt: undefined,
     updatedAt: undefined,
   };
 }
 
-export const Sla: MessageFns<Sla> = {
-  encode(message: Sla, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const Slo: MessageFns<Slo> = {
+  encode(message: Slo, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.id !== "") {
       writer.uint32(10).string(message.id);
     }
@@ -324,28 +281,22 @@ export const Sla: MessageFns<Sla> = {
     if (message.enabled !== false) {
       writer.uint32(48).bool(message.enabled);
     }
-    if (message.check !== undefined) {
-      SlaCheck.encode(message.check, writer.uint32(58).fork()).join();
-    }
-    if (message.currentRevision !== 0) {
-      writer.uint32(64).int32(message.currentRevision);
-    }
-    if (message.metricName !== "") {
-      writer.uint32(74).string(message.metricName);
+    if (message.objective !== undefined) {
+      SloObjective.encode(message.objective, writer.uint32(58).fork()).join();
     }
     if (message.createdAt !== undefined) {
-      Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(82).fork()).join();
+      Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(66).fork()).join();
     }
     if (message.updatedAt !== undefined) {
-      Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(90).fork()).join();
+      Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(74).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): Sla {
+  decode(input: BinaryReader | Uint8Array, length?: number): Slo {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseSla();
+    const message = createBaseSlo();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -402,15 +353,15 @@ export const Sla: MessageFns<Sla> = {
             break;
           }
 
-          message.check = SlaCheck.decode(reader, reader.uint32());
+          message.objective = SloObjective.decode(reader, reader.uint32());
           continue;
         }
         case 8: {
-          if (tag !== 64) {
+          if (tag !== 66) {
             break;
           }
 
-          message.currentRevision = reader.int32();
+          message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           continue;
         }
         case 9: {
@@ -418,22 +369,6 @@ export const Sla: MessageFns<Sla> = {
             break;
           }
 
-          message.metricName = reader.string();
-          continue;
-        }
-        case 10: {
-          if (tag !== 82) {
-            break;
-          }
-
-          message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
-          continue;
-        }
-        case 11: {
-          if (tag !== 90) {
-            break;
-          }
-
           message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           continue;
         }
@@ -446,7 +381,7 @@ export const Sla: MessageFns<Sla> = {
     return message;
   },
 
-  fromJSON(object: any): Sla {
+  fromJSON(object: any): Slo {
     return {
       id: isSet(object.id) ? globalThis.String(object.id) : "",
       organizationId: isSet(object.organizationId)
@@ -462,17 +397,7 @@ export const Sla: MessageFns<Sla> = {
       name: isSet(object.name) ? globalThis.String(object.name) : "",
       description: isSet(object.description) ? globalThis.String(object.description) : "",
       enabled: isSet(object.enabled) ? globalThis.Boolean(object.enabled) : false,
-      check: isSet(object.check) ? SlaCheck.fromJSON(object.check) : undefined,
-      currentRevision: isSet(object.currentRevision)
-        ? globalThis.Number(object.currentRevision)
-        : isSet(object.current_revision)
-        ? globalThis.Number(object.current_revision)
-        : 0,
-      metricName: isSet(object.metricName)
-        ? globalThis.String(object.metricName)
-        : isSet(object.metric_name)
-        ? globalThis.String(object.metric_name)
-        : "",
+      objective: isSet(object.objective) ? SloObjective.fromJSON(object.objective) : undefined,
       createdAt: isSet(object.createdAt)
         ? fromJsonTimestamp(object.createdAt)
         : isSet(object.created_at)
@@ -486,7 +411,7 @@ export const Sla: MessageFns<Sla> = {
     };
   },
 
-  toJSON(message: Sla): unknown {
+  toJSON(message: Slo): unknown {
     const obj: any = {};
     if (message.id !== "") {
       obj.id = message.id;
@@ -506,14 +431,8 @@ export const Sla: MessageFns<Sla> = {
     if (message.enabled !== false) {
       obj.enabled = message.enabled;
     }
-    if (message.check !== undefined) {
-      obj.check = SlaCheck.toJSON(message.check);
-    }
-    if (message.currentRevision !== 0) {
-      obj.currentRevision = Math.round(message.currentRevision);
-    }
-    if (message.metricName !== "") {
-      obj.metricName = message.metricName;
+    if (message.objective !== undefined) {
+      obj.objective = SloObjective.toJSON(message.objective);
     }
     if (message.createdAt !== undefined) {
       obj.createdAt = message.createdAt.toISOString();
@@ -524,53 +443,54 @@ export const Sla: MessageFns<Sla> = {
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<Sla>, I>>(base?: I): Sla {
-    return Sla.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<Slo>, I>>(base?: I): Slo {
+    return Slo.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<Sla>, I>>(object: I): Sla {
-    const message = createBaseSla();
+  fromPartial<I extends Exact<DeepPartial<Slo>, I>>(object: I): Slo {
+    const message = createBaseSlo();
     message.id = object.id ?? "";
     message.organizationId = object.organizationId ?? "";
     message.projectId = object.projectId ?? "";
     message.name = object.name ?? "";
     message.description = object.description ?? "";
     message.enabled = object.enabled ?? false;
-    message.check = (object.check !== undefined && object.check !== null)
-      ? SlaCheck.fromPartial(object.check)
+    message.objective = (object.objective !== undefined && object.objective !== null)
+      ? SloObjective.fromPartial(object.objective)
       : undefined;
-    message.currentRevision = object.currentRevision ?? 0;
-    message.metricName = object.metricName ?? "";
     message.createdAt = object.createdAt ?? undefined;
     message.updatedAt = object.updatedAt ?? undefined;
     return message;
   },
 };
 
-function createBaseSlaCheck(): SlaCheck {
-  return { sideA: undefined, sideB: undefined, comparator: 0, threshold: 0 };
+function createBaseSloObjective(): SloObjective {
+  return { metricName: "", groupBy: [], target: 0, windowSeconds: 0, gaugeThreshold: undefined };
 }
 
-export const SlaCheck: MessageFns<SlaCheck> = {
-  encode(message: SlaCheck, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.sideA !== undefined) {
-      SlaAttributeRef.encode(message.sideA, writer.uint32(10).fork()).join();
+export const SloObjective: MessageFns<SloObjective> = {
+  encode(message: SloObjective, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.metricName !== "") {
+      writer.uint32(10).string(message.metricName);
     }
-    if (message.sideB !== undefined) {
-      SlaAttributeRef.encode(message.sideB, writer.uint32(18).fork()).join();
+    for (const v of message.groupBy) {
+      writer.uint32(18).string(v!);
     }
-    if (message.comparator !== 0) {
-      writer.uint32(24).int32(message.comparator);
+    if (message.target !== 0) {
+      writer.uint32(25).double(message.target);
     }
-    if (message.threshold !== 0) {
-      writer.uint32(33).double(message.threshold);
+    if (message.windowSeconds !== 0) {
+      writer.uint32(32).int64(message.windowSeconds);
+    }
+    if (message.gaugeThreshold !== undefined) {
+      GaugeThresholdSli.encode(message.gaugeThreshold, writer.uint32(42).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): SlaCheck {
+  decode(input: BinaryReader | Uint8Array, length?: number): SloObjective {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseSlaCheck();
+    const message = createBaseSloObjective();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -579,7 +499,7 @@ export const SlaCheck: MessageFns<SlaCheck> = {
             break;
           }
 
-          message.sideA = SlaAttributeRef.decode(reader, reader.uint32());
+          message.metricName = reader.string();
           continue;
         }
         case 2: {
@@ -587,132 +507,31 @@ export const SlaCheck: MessageFns<SlaCheck> = {
             break;
           }
 
-          message.sideB = SlaAttributeRef.decode(reader, reader.uint32());
+          message.groupBy.push(reader.string());
           continue;
         }
         case 3: {
-          if (tag !== 24) {
+          if (tag !== 25) {
             break;
           }
 
-          message.comparator = reader.int32() as any;
+          message.target = reader.double();
           continue;
         }
         case 4: {
-          if (tag !== 33) {
-            break;
-          }
-
-          message.threshold = reader.double();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-
-  fromJSON(object: any): SlaCheck {
-    return {
-      sideA: isSet(object.sideA)
-        ? SlaAttributeRef.fromJSON(object.sideA)
-        : isSet(object.side_a)
-        ? SlaAttributeRef.fromJSON(object.side_a)
-        : undefined,
-      sideB: isSet(object.sideB)
-        ? SlaAttributeRef.fromJSON(object.sideB)
-        : isSet(object.side_b)
-        ? SlaAttributeRef.fromJSON(object.side_b)
-        : undefined,
-      comparator: isSet(object.comparator) ? slaComparatorFromJSON(object.comparator) : 0,
-      threshold: isSet(object.threshold) ? globalThis.Number(object.threshold) : 0,
-    };
-  },
-
-  toJSON(message: SlaCheck): unknown {
-    const obj: any = {};
-    if (message.sideA !== undefined) {
-      obj.sideA = SlaAttributeRef.toJSON(message.sideA);
-    }
-    if (message.sideB !== undefined) {
-      obj.sideB = SlaAttributeRef.toJSON(message.sideB);
-    }
-    if (message.comparator !== 0) {
-      obj.comparator = slaComparatorToJSON(message.comparator);
-    }
-    if (message.threshold !== 0) {
-      obj.threshold = message.threshold;
-    }
-    return obj;
-  },
-
-  create<I extends Exact<DeepPartial<SlaCheck>, I>>(base?: I): SlaCheck {
-    return SlaCheck.fromPartial(base ?? ({} as any));
-  },
-  fromPartial<I extends Exact<DeepPartial<SlaCheck>, I>>(object: I): SlaCheck {
-    const message = createBaseSlaCheck();
-    message.sideA = (object.sideA !== undefined && object.sideA !== null)
-      ? SlaAttributeRef.fromPartial(object.sideA)
-      : undefined;
-    message.sideB = (object.sideB !== undefined && object.sideB !== null)
-      ? SlaAttributeRef.fromPartial(object.sideB)
-      : undefined;
-    message.comparator = object.comparator ?? 0;
-    message.threshold = object.threshold ?? 0;
-    return message;
-  },
-};
-
-function createBaseSlaAttributeRef(): SlaAttributeRef {
-  return { attributeKey: "", eventName: "", occurrence: 0 };
-}
-
-export const SlaAttributeRef: MessageFns<SlaAttributeRef> = {
-  encode(message: SlaAttributeRef, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.attributeKey !== "") {
-      writer.uint32(10).string(message.attributeKey);
-    }
-    if (message.eventName !== "") {
-      writer.uint32(18).string(message.eventName);
-    }
-    if (message.occurrence !== 0) {
-      writer.uint32(24).int32(message.occurrence);
-    }
-    return writer;
-  },
-
-  decode(input: BinaryReader | Uint8Array, length?: number): SlaAttributeRef {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseSlaAttributeRef();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-
-          message.attributeKey = reader.string();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
+          if (tag !== 32) {
             break;
           }
 
-          message.eventName = reader.string();
+          message.windowSeconds = longToNumber(reader.int64());
           continue;
         }
-        case 3: {
-          if (tag !== 24) {
+        case 5: {
+          if (tag !== 42) {
             break;
           }
 
-          message.occurrence = reader.int32() as any;
+          message.gaugeThreshold = GaugeThresholdSli.decode(reader, reader.uint32());
           continue;
         }
       }
@@ -724,195 +543,104 @@ export const SlaAttributeRef: MessageFns<SlaAttributeRef> = {
     return message;
   },
 
-  fromJSON(object: any): SlaAttributeRef {
+  fromJSON(object: any): SloObjective {
     return {
-      attributeKey: isSet(object.attributeKey)
-        ? globalThis.String(object.attributeKey)
-        : isSet(object.attribute_key)
-        ? globalThis.String(object.attribute_key)
-        : "",
-      eventName: isSet(object.eventName)
-        ? globalThis.String(object.eventName)
-        : isSet(object.event_name)
-        ? globalThis.String(object.event_name)
+      metricName: isSet(object.metricName)
+        ? globalThis.String(object.metricName)
+        : isSet(object.metric_name)
+        ? globalThis.String(object.metric_name)
         : "",
-      occurrence: isSet(object.occurrence) ? slaOccurrenceFromJSON(object.occurrence) : 0,
+      groupBy: globalThis.Array.isArray(object?.groupBy)
+        ? object.groupBy.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.group_by)
+        ? object.group_by.map((e: any) => globalThis.String(e))
+        : [],
+      target: isSet(object.target) ? globalThis.Number(object.target) : 0,
+      windowSeconds: isSet(object.windowSeconds)
+        ? globalThis.Number(object.windowSeconds)
+        : isSet(object.window_seconds)
+        ? globalThis.Number(object.window_seconds)
+        : 0,
+      gaugeThreshold: isSet(object.gaugeThreshold)
+        ? GaugeThresholdSli.fromJSON(object.gaugeThreshold)
+        : isSet(object.gauge_threshold)
+        ? GaugeThresholdSli.fromJSON(object.gauge_threshold)
+        : undefined,
     };
   },
 
-  toJSON(message: SlaAttributeRef): unknown {
+  toJSON(message: SloObjective): unknown {
     const obj: any = {};
-    if (message.attributeKey !== "") {
-      obj.attributeKey = message.attributeKey;
+    if (message.metricName !== "") {
+      obj.metricName = message.metricName;
     }
-    if (message.eventName !== "") {
-      obj.eventName = message.eventName;
+    if (message.groupBy?.length) {
+      obj.groupBy = message.groupBy;
     }
-    if (message.occurrence !== 0) {
-      obj.occurrence = slaOccurrenceToJSON(message.occurrence);
+    if (message.target !== 0) {
+      obj.target = message.target;
+    }
+    if (message.windowSeconds !== 0) {
+      obj.windowSeconds = Math.round(message.windowSeconds);
+    }
+    if (message.gaugeThreshold !== undefined) {
+      obj.gaugeThreshold = GaugeThresholdSli.toJSON(message.gaugeThreshold);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<SlaAttributeRef>, I>>(base?: I): SlaAttributeRef {
-    return SlaAttributeRef.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<SloObjective>, I>>(base?: I): SloObjective {
+    return SloObjective.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<SlaAttributeRef>, I>>(object: I): SlaAttributeRef {
-    const message = createBaseSlaAttributeRef();
-    message.attributeKey = object.attributeKey ?? "";
-    message.eventName = object.eventName ?? "";
-    message.occurrence = object.occurrence ?? 0;
+  fromPartial<I extends Exact<DeepPartial<SloObjective>, I>>(object: I): SloObjective {
+    const message = createBaseSloObjective();
+    message.metricName = object.metricName ?? "";
+    message.groupBy = object.groupBy?.map((e) => e) || [];
+    message.target = object.target ?? 0;
+    message.windowSeconds = object.windowSeconds ?? 0;
+    message.gaugeThreshold = (object.gaugeThreshold !== undefined && object.gaugeThreshold !== null)
+      ? GaugeThresholdSli.fromPartial(object.gaugeThreshold)
+      : undefined;
     return message;
   },
 };
 
-function createBaseSlaOutcome(): SlaOutcome {
-  return {
-    slaId: "",
-    revision: 0,
-    traceId: "",
-    terminalVersion: 0,
-    outcome: 0,
-    sideAValue: undefined,
-    sideBValue: undefined,
-    diff: undefined,
-    reasonCode: "",
-    traceFinishedAt: undefined,
-    evaluatedAt: undefined,
-  };
+function createBaseGaugeThresholdSli(): GaugeThresholdSli {
+  return { comparator: 0, threshold: 0 };
 }
 
-export const SlaOutcome: MessageFns<SlaOutcome> = {
-  encode(message: SlaOutcome, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.slaId !== "") {
-      writer.uint32(10).string(message.slaId);
-    }
-    if (message.revision !== 0) {
-      writer.uint32(16).int32(message.revision);
-    }
-    if (message.traceId !== "") {
-      writer.uint32(26).string(message.traceId);
-    }
-    if (message.terminalVersion !== 0) {
-      writer.uint32(32).uint64(message.terminalVersion);
-    }
-    if (message.outcome !== 0) {
-      writer.uint32(40).int32(message.outcome);
-    }
-    if (message.sideAValue !== undefined) {
-      writer.uint32(49).double(message.sideAValue);
-    }
-    if (message.sideBValue !== undefined) {
-      writer.uint32(57).double(message.sideBValue);
-    }
-    if (message.diff !== undefined) {
-      writer.uint32(65).double(message.diff);
-    }
-    if (message.reasonCode !== "") {
-      writer.uint32(74).string(message.reasonCode);
-    }
-    if (message.traceFinishedAt !== undefined) {
-      Timestamp.encode(toTimestamp(message.traceFinishedAt), writer.uint32(82).fork()).join();
+export const GaugeThresholdSli: MessageFns<GaugeThresholdSli> = {
+  encode(message: GaugeThresholdSli, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.comparator !== 0) {
+      writer.uint32(8).int32(message.comparator);
     }
-    if (message.evaluatedAt !== undefined) {
-      Timestamp.encode(toTimestamp(message.evaluatedAt), writer.uint32(90).fork()).join();
+    if (message.threshold !== 0) {
+      writer.uint32(17).double(message.threshold);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): SlaOutcome {
+  decode(input: BinaryReader | Uint8Array, length?: number): GaugeThresholdSli {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseSlaOutcome();
+    const message = createBaseGaugeThresholdSli();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1: {
-          if (tag !== 10) {
+          if (tag !== 8) {
             break;
           }
 
-          message.slaId = reader.string();
+          message.comparator = reader.int32() as any;
           continue;
         }
         case 2: {
-          if (tag !== 16) {
-            break;
-          }
-
-          message.revision = reader.int32();
-          continue;
-        }
-        case 3: {
-          if (tag !== 26) {
-            break;
-          }
-
-          message.traceId = reader.string();
-          continue;
-        }
-        case 4: {
-          if (tag !== 32) {
-            break;
-          }
-
-          message.terminalVersion = longToNumber(reader.uint64());
-          continue;
-        }
-        case 5: {
-          if (tag !== 40) {
-            break;
-          }
-
-          message.outcome = reader.int32() as any;
-          continue;
-        }
-        case 6: {
-          if (tag !== 49) {
-            break;
-          }
-
-          message.sideAValue = reader.double();
-          continue;
-        }
-        case 7: {
-          if (tag !== 57) {
-            break;
-          }
-
-          message.sideBValue = reader.double();
-          continue;
-        }
-        case 8: {
-          if (tag !== 65) {
-            break;
-          }
-
-          message.diff = reader.double();
-          continue;
-        }
-        case 9: {
-          if (tag !== 74) {
-            break;
-          }
-
-          message.reasonCode = reader.string();
-          continue;
-        }
-        case 10: {
-          if (tag !== 82) {
-            break;
-          }
-
-          message.traceFinishedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
-          continue;
-        }
-        case 11: {
-          if (tag !== 90) {
+          if (tag !== 17) {
             break;
           }
 
-          message.evaluatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          message.threshold = reader.double();
           continue;
         }
       }
@@ -924,118 +652,41 @@ export const SlaOutcome: MessageFns<SlaOutcome> = {
     return message;
   },
 
-  fromJSON(object: any): SlaOutcome {
+  fromJSON(object: any): GaugeThresholdSli {
     return {
-      slaId: isSet(object.slaId)
-        ? globalThis.String(object.slaId)
-        : isSet(object.sla_id)
-        ? globalThis.String(object.sla_id)
-        : "",
-      revision: isSet(object.revision) ? globalThis.Number(object.revision) : 0,
-      traceId: isSet(object.traceId)
-        ? globalThis.String(object.traceId)
-        : isSet(object.trace_id)
-        ? globalThis.String(object.trace_id)
-        : "",
-      terminalVersion: isSet(object.terminalVersion)
-        ? globalThis.Number(object.terminalVersion)
-        : isSet(object.terminal_version)
-        ? globalThis.Number(object.terminal_version)
-        : 0,
-      outcome: isSet(object.outcome) ? slaOutcomeStatusFromJSON(object.outcome) : 0,
-      sideAValue: isSet(object.sideAValue)
-        ? globalThis.Number(object.sideAValue)
-        : isSet(object.side_a_value)
-        ? globalThis.Number(object.side_a_value)
-        : undefined,
-      sideBValue: isSet(object.sideBValue)
-        ? globalThis.Number(object.sideBValue)
-        : isSet(object.side_b_value)
-        ? globalThis.Number(object.side_b_value)
-        : undefined,
-      diff: isSet(object.diff) ? globalThis.Number(object.diff) : undefined,
-      reasonCode: isSet(object.reasonCode)
-        ? globalThis.String(object.reasonCode)
-        : isSet(object.reason_code)
-        ? globalThis.String(object.reason_code)
-        : "",
-      traceFinishedAt: isSet(object.traceFinishedAt)
-        ? fromJsonTimestamp(object.traceFinishedAt)
-        : isSet(object.trace_finished_at)
-        ? fromJsonTimestamp(object.trace_finished_at)
-        : undefined,
-      evaluatedAt: isSet(object.evaluatedAt)
-        ? fromJsonTimestamp(object.evaluatedAt)
-        : isSet(object.evaluated_at)
-        ? fromJsonTimestamp(object.evaluated_at)
-        : undefined,
+      comparator: isSet(object.comparator) ? sloComparatorFromJSON(object.comparator) : 0,
+      threshold: isSet(object.threshold) ? globalThis.Number(object.threshold) : 0,
     };
   },
 
-  toJSON(message: SlaOutcome): unknown {
+  toJSON(message: GaugeThresholdSli): unknown {
     const obj: any = {};
-    if (message.slaId !== "") {
-      obj.slaId = message.slaId;
-    }
-    if (message.revision !== 0) {
-      obj.revision = Math.round(message.revision);
-    }
-    if (message.traceId !== "") {
-      obj.traceId = message.traceId;
-    }
-    if (message.terminalVersion !== 0) {
-      obj.terminalVersion = Math.round(message.terminalVersion);
-    }
-    if (message.outcome !== 0) {
-      obj.outcome = slaOutcomeStatusToJSON(message.outcome);
-    }
-    if (message.sideAValue !== undefined) {
-      obj.sideAValue = message.sideAValue;
-    }
-    if (message.sideBValue !== undefined) {
-      obj.sideBValue = message.sideBValue;
-    }
-    if (message.diff !== undefined) {
-      obj.diff = message.diff;
-    }
-    if (message.reasonCode !== "") {
-      obj.reasonCode = message.reasonCode;
-    }
-    if (message.traceFinishedAt !== undefined) {
-      obj.traceFinishedAt = message.traceFinishedAt.toISOString();
+    if (message.comparator !== 0) {
+      obj.comparator = sloComparatorToJSON(message.comparator);
     }
-    if (message.evaluatedAt !== undefined) {
-      obj.evaluatedAt = message.evaluatedAt.toISOString();
+    if (message.threshold !== 0) {
+      obj.threshold = message.threshold;
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<SlaOutcome>, I>>(base?: I): SlaOutcome {
-    return SlaOutcome.fromPartial(base ?? ({} as any));
-  },
-  fromPartial<I extends Exact<DeepPartial<SlaOutcome>, I>>(object: I): SlaOutcome {
-    const message = createBaseSlaOutcome();
-    message.slaId = object.slaId ?? "";
-    message.revision = object.revision ?? 0;
-    message.traceId = object.traceId ?? "";
-    message.terminalVersion = object.terminalVersion ?? 0;
-    message.outcome = object.outcome ?? 0;
-    message.sideAValue = object.sideAValue ?? undefined;
-    message.sideBValue = object.sideBValue ?? undefined;
-    message.diff = object.diff ?? undefined;
-    message.reasonCode = object.reasonCode ?? "";
-    message.traceFinishedAt = object.traceFinishedAt ?? undefined;
-    message.evaluatedAt = object.evaluatedAt ?? undefined;
+  create<I extends Exact<DeepPartial<GaugeThresholdSli>, I>>(base?: I): GaugeThresholdSli {
+    return GaugeThresholdSli.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GaugeThresholdSli>, I>>(object: I): GaugeThresholdSli {
+    const message = createBaseGaugeThresholdSli();
+    message.comparator = object.comparator ?? 0;
+    message.threshold = object.threshold ?? 0;
     return message;
   },
 };
 
-function createBaseCreateSlaRequest(): CreateSlaRequest {
-  return { organizationId: "", projectId: "", name: "", description: "", enabled: false, check: undefined };
+function createBaseCreateSloRequest(): CreateSloRequest {
+  return { organizationId: "", projectId: "", name: "", description: "", enabled: false, objective: undefined };
 }
 
-export const CreateSlaRequest: MessageFns<CreateSlaRequest> = {
-  encode(message: CreateSlaRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const CreateSloRequest: MessageFns<CreateSloRequest> = {
+  encode(message: CreateSloRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.organizationId !== "") {
       writer.uint32(10).string(message.organizationId);
     }
@@ -1051,16 +702,16 @@ export const CreateSlaRequest: MessageFns<CreateSlaRequest> = {
     if (message.enabled !== false) {
       writer.uint32(40).bool(message.enabled);
     }
-    if (message.check !== undefined) {
-      SlaCheck.encode(message.check, writer.uint32(50).fork()).join();
+    if (message.objective !== undefined) {
+      SloObjective.encode(message.objective, writer.uint32(50).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): CreateSlaRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateSloRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseCreateSlaRequest();
+    const message = createBaseCreateSloRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1109,7 +760,7 @@ export const CreateSlaRequest: MessageFns<CreateSlaRequest> = {
             break;
           }
 
-          message.check = SlaCheck.decode(reader, reader.uint32());
+          message.objective = SloObjective.decode(reader, reader.uint32());
           continue;
         }
       }
@@ -1121,7 +772,7 @@ export const CreateSlaRequest: MessageFns<CreateSlaRequest> = {
     return message;
   },
 
-  fromJSON(object: any): CreateSlaRequest {
+  fromJSON(object: any): CreateSloRequest {
     return {
       organizationId: isSet(object.organizationId)
         ? globalThis.String(object.organizationId)
@@ -1136,11 +787,11 @@ export const CreateSlaRequest: MessageFns<CreateSlaRequest> = {
       name: isSet(object.name) ? globalThis.String(object.name) : "",
       description: isSet(object.description) ? globalThis.String(object.description) : "",
       enabled: isSet(object.enabled) ? globalThis.Boolean(object.enabled) : false,
-      check: isSet(object.check) ? SlaCheck.fromJSON(object.check) : undefined,
+      objective: isSet(object.objective) ? SloObjective.fromJSON(object.objective) : undefined,
     };
   },
 
-  toJSON(message: CreateSlaRequest): unknown {
+  toJSON(message: CreateSloRequest): unknown {
     const obj: any = {};
     if (message.organizationId !== "") {
       obj.organizationId = message.organizationId;
@@ -1157,48 +808,48 @@ export const CreateSlaRequest: MessageFns<CreateSlaRequest> = {
     if (message.enabled !== false) {
       obj.enabled = message.enabled;
     }
-    if (message.check !== undefined) {
-      obj.check = SlaCheck.toJSON(message.check);
+    if (message.objective !== undefined) {
+      obj.objective = SloObjective.toJSON(message.objective);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<CreateSlaRequest>, I>>(base?: I): CreateSlaRequest {
-    return CreateSlaRequest.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<CreateSloRequest>, I>>(base?: I): CreateSloRequest {
+    return CreateSloRequest.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<CreateSlaRequest>, I>>(object: I): CreateSlaRequest {
-    const message = createBaseCreateSlaRequest();
+  fromPartial<I extends Exact<DeepPartial<CreateSloRequest>, I>>(object: I): CreateSloRequest {
+    const message = createBaseCreateSloRequest();
     message.organizationId = object.organizationId ?? "";
     message.projectId = object.projectId ?? "";
     message.name = object.name ?? "";
     message.description = object.description ?? "";
     message.enabled = object.enabled ?? false;
-    message.check = (object.check !== undefined && object.check !== null)
-      ? SlaCheck.fromPartial(object.check)
+    message.objective = (object.objective !== undefined && object.objective !== null)
+      ? SloObjective.fromPartial(object.objective)
       : undefined;
     return message;
   },
 };
 
-function createBaseCreateSlaResponse(): CreateSlaResponse {
-  return { status: undefined, sla: undefined };
+function createBaseCreateSloResponse(): CreateSloResponse {
+  return { status: undefined, slo: undefined };
 }
 
-export const CreateSlaResponse: MessageFns<CreateSlaResponse> = {
-  encode(message: CreateSlaResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const CreateSloResponse: MessageFns<CreateSloResponse> = {
+  encode(message: CreateSloResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.status !== undefined) {
       ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
     }
-    if (message.sla !== undefined) {
-      Sla.encode(message.sla, writer.uint32(18).fork()).join();
+    if (message.slo !== undefined) {
+      Slo.encode(message.slo, writer.uint32(18).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): CreateSlaResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateSloResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseCreateSlaResponse();
+    const message = createBaseCreateSloResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1215,7 +866,7 @@ export const CreateSlaResponse: MessageFns<CreateSlaResponse> = {
             break;
           }
 
-          message.sla = Sla.decode(reader, reader.uint32());
+          message.slo = Slo.decode(reader, reader.uint32());
           continue;
         }
       }
@@ -1227,59 +878,59 @@ export const CreateSlaResponse: MessageFns<CreateSlaResponse> = {
     return message;
   },
 
-  fromJSON(object: any): CreateSlaResponse {
+  fromJSON(object: any): CreateSloResponse {
     return {
       status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
-      sla: isSet(object.sla) ? Sla.fromJSON(object.sla) : undefined,
+      slo: isSet(object.slo) ? Slo.fromJSON(object.slo) : undefined,
     };
   },
 
-  toJSON(message: CreateSlaResponse): unknown {
+  toJSON(message: CreateSloResponse): unknown {
     const obj: any = {};
     if (message.status !== undefined) {
       obj.status = ResponseStatus.toJSON(message.status);
     }
-    if (message.sla !== undefined) {
-      obj.sla = Sla.toJSON(message.sla);
+    if (message.slo !== undefined) {
+      obj.slo = Slo.toJSON(message.slo);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<CreateSlaResponse>, I>>(base?: I): CreateSlaResponse {
-    return CreateSlaResponse.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<CreateSloResponse>, I>>(base?: I): CreateSloResponse {
+    return CreateSloResponse.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<CreateSlaResponse>, I>>(object: I): CreateSlaResponse {
-    const message = createBaseCreateSlaResponse();
+  fromPartial<I extends Exact<DeepPartial<CreateSloResponse>, I>>(object: I): CreateSloResponse {
+    const message = createBaseCreateSloResponse();
     message.status = (object.status !== undefined && object.status !== null)
       ? ResponseStatus.fromPartial(object.status)
       : undefined;
-    message.sla = (object.sla !== undefined && object.sla !== null) ? Sla.fromPartial(object.sla) : undefined;
+    message.slo = (object.slo !== undefined && object.slo !== null) ? Slo.fromPartial(object.slo) : undefined;
     return message;
   },
 };
 
-function createBaseGetSlaRequest(): GetSlaRequest {
-  return { organizationId: "", projectId: "", slaId: "" };
+function createBaseGetSloRequest(): GetSloRequest {
+  return { organizationId: "", projectId: "", sloId: "" };
 }
 
-export const GetSlaRequest: MessageFns<GetSlaRequest> = {
-  encode(message: GetSlaRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const GetSloRequest: MessageFns<GetSloRequest> = {
+  encode(message: GetSloRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.organizationId !== "") {
       writer.uint32(10).string(message.organizationId);
     }
     if (message.projectId !== "") {
       writer.uint32(18).string(message.projectId);
     }
-    if (message.slaId !== "") {
-      writer.uint32(26).string(message.slaId);
+    if (message.sloId !== "") {
+      writer.uint32(26).string(message.sloId);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): GetSlaRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): GetSloRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseGetSlaRequest();
+    const message = createBaseGetSloRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1304,7 +955,7 @@ export const GetSlaRequest: MessageFns<GetSlaRequest> = {
             break;
           }
 
-          message.slaId = reader.string();
+          message.sloId = reader.string();
           continue;
         }
       }
@@ -1316,7 +967,7 @@ export const GetSlaRequest: MessageFns<GetSlaRequest> = {
     return message;
   },
 
-  fromJSON(object: any): GetSlaRequest {
+  fromJSON(object: any): GetSloRequest {
     return {
       organizationId: isSet(object.organizationId)
         ? globalThis.String(object.organizationId)
@@ -1328,15 +979,15 @@ export const GetSlaRequest: MessageFns<GetSlaRequest> = {
         : isSet(object.project_id)
         ? globalThis.String(object.project_id)
         : "",
-      slaId: isSet(object.slaId)
-        ? globalThis.String(object.slaId)
-        : isSet(object.sla_id)
-        ? globalThis.String(object.sla_id)
+      sloId: isSet(object.sloId)
+        ? globalThis.String(object.sloId)
+        : isSet(object.slo_id)
+        ? globalThis.String(object.slo_id)
         : "",
     };
   },
 
-  toJSON(message: GetSlaRequest): unknown {
+  toJSON(message: GetSloRequest): unknown {
     const obj: any = {};
     if (message.organizationId !== "") {
       obj.organizationId = message.organizationId;
@@ -1344,43 +995,43 @@ export const GetSlaRequest: MessageFns<GetSlaRequest> = {
     if (message.projectId !== "") {
       obj.projectId = message.projectId;
     }
-    if (message.slaId !== "") {
-      obj.slaId = message.slaId;
+    if (message.sloId !== "") {
+      obj.sloId = message.sloId;
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<GetSlaRequest>, I>>(base?: I): GetSlaRequest {
-    return GetSlaRequest.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<GetSloRequest>, I>>(base?: I): GetSloRequest {
+    return GetSloRequest.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<GetSlaRequest>, I>>(object: I): GetSlaRequest {
-    const message = createBaseGetSlaRequest();
+  fromPartial<I extends Exact<DeepPartial<GetSloRequest>, I>>(object: I): GetSloRequest {
+    const message = createBaseGetSloRequest();
     message.organizationId = object.organizationId ?? "";
     message.projectId = object.projectId ?? "";
-    message.slaId = object.slaId ?? "";
+    message.sloId = object.sloId ?? "";
     return message;
   },
 };
 
-function createBaseGetSlaResponse(): GetSlaResponse {
-  return { status: undefined, sla: undefined };
+function createBaseGetSloResponse(): GetSloResponse {
+  return { status: undefined, slo: undefined };
 }
 
-export const GetSlaResponse: MessageFns<GetSlaResponse> = {
-  encode(message: GetSlaResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const GetSloResponse: MessageFns<GetSloResponse> = {
+  encode(message: GetSloResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.status !== undefined) {
       ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
     }
-    if (message.sla !== undefined) {
-      Sla.encode(message.sla, writer.uint32(18).fork()).join();
+    if (message.slo !== undefined) {
+      Slo.encode(message.slo, writer.uint32(18).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): GetSlaResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): GetSloResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseGetSlaResponse();
+    const message = createBaseGetSloResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1397,7 +1048,7 @@ export const GetSlaResponse: MessageFns<GetSlaResponse> = {
             break;
           }
 
-          message.sla = Sla.decode(reader, reader.uint32());
+          message.slo = Slo.decode(reader, reader.uint32());
           continue;
         }
       }
@@ -1409,43 +1060,43 @@ export const GetSlaResponse: MessageFns<GetSlaResponse> = {
     return message;
   },
 
-  fromJSON(object: any): GetSlaResponse {
+  fromJSON(object: any): GetSloResponse {
     return {
       status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
-      sla: isSet(object.sla) ? Sla.fromJSON(object.sla) : undefined,
+      slo: isSet(object.slo) ? Slo.fromJSON(object.slo) : undefined,
     };
   },
 
-  toJSON(message: GetSlaResponse): unknown {
+  toJSON(message: GetSloResponse): unknown {
     const obj: any = {};
     if (message.status !== undefined) {
       obj.status = ResponseStatus.toJSON(message.status);
     }
-    if (message.sla !== undefined) {
-      obj.sla = Sla.toJSON(message.sla);
+    if (message.slo !== undefined) {
+      obj.slo = Slo.toJSON(message.slo);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<GetSlaResponse>, I>>(base?: I): GetSlaResponse {
-    return GetSlaResponse.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<GetSloResponse>, I>>(base?: I): GetSloResponse {
+    return GetSloResponse.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<GetSlaResponse>, I>>(object: I): GetSlaResponse {
-    const message = createBaseGetSlaResponse();
+  fromPartial<I extends Exact<DeepPartial<GetSloResponse>, I>>(object: I): GetSloResponse {
+    const message = createBaseGetSloResponse();
     message.status = (object.status !== undefined && object.status !== null)
       ? ResponseStatus.fromPartial(object.status)
       : undefined;
-    message.sla = (object.sla !== undefined && object.sla !== null) ? Sla.fromPartial(object.sla) : undefined;
+    message.slo = (object.slo !== undefined && object.slo !== null) ? Slo.fromPartial(object.slo) : undefined;
     return message;
   },
 };
 
-function createBaseListSlasRequest(): ListSlasRequest {
+function createBaseListSlosRequest(): ListSlosRequest {
   return { organizationId: "", projectId: "" };
 }
 
-export const ListSlasRequest: MessageFns<ListSlasRequest> = {
-  encode(message: ListSlasRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const ListSlosRequest: MessageFns<ListSlosRequest> = {
+  encode(message: ListSlosRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.organizationId !== "") {
       writer.uint32(10).string(message.organizationId);
     }
@@ -1455,10 +1106,10 @@ export const ListSlasRequest: MessageFns<ListSlasRequest> = {
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): ListSlasRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): ListSlosRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseListSlasRequest();
+    const message = createBaseListSlosRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1487,7 +1138,7 @@ export const ListSlasRequest: MessageFns<ListSlasRequest> = {
     return message;
   },
 
-  fromJSON(object: any): ListSlasRequest {
+  fromJSON(object: any): ListSlosRequest {
     return {
       organizationId: isSet(object.organizationId)
         ? globalThis.String(object.organizationId)
@@ -1502,7 +1153,7 @@ export const ListSlasRequest: MessageFns<ListSlasRequest> = {
     };
   },
 
-  toJSON(message: ListSlasRequest): unknown {
+  toJSON(message: ListSlosRequest): unknown {
     const obj: any = {};
     if (message.organizationId !== "") {
       obj.organizationId = message.organizationId;
@@ -1513,36 +1164,36 @@ export const ListSlasRequest: MessageFns<ListSlasRequest> = {
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<ListSlasRequest>, I>>(base?: I): ListSlasRequest {
-    return ListSlasRequest.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<ListSlosRequest>, I>>(base?: I): ListSlosRequest {
+    return ListSlosRequest.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<ListSlasRequest>, I>>(object: I): ListSlasRequest {
-    const message = createBaseListSlasRequest();
+  fromPartial<I extends Exact<DeepPartial<ListSlosRequest>, I>>(object: I): ListSlosRequest {
+    const message = createBaseListSlosRequest();
     message.organizationId = object.organizationId ?? "";
     message.projectId = object.projectId ?? "";
     return message;
   },
 };
 
-function createBaseListSlasResponse(): ListSlasResponse {
-  return { status: undefined, slas: [] };
+function createBaseListSlosResponse(): ListSlosResponse {
+  return { status: undefined, slos: [] };
 }
 
-export const ListSlasResponse: MessageFns<ListSlasResponse> = {
-  encode(message: ListSlasResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const ListSlosResponse: MessageFns<ListSlosResponse> = {
+  encode(message: ListSlosResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.status !== undefined) {
       ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
     }
-    for (const v of message.slas) {
-      Sla.encode(v!, writer.uint32(18).fork()).join();
+    for (const v of message.slos) {
+      Slo.encode(v!, writer.uint32(18).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): ListSlasResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): ListSlosResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseListSlasResponse();
+    const message = createBaseListSlosResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1559,7 +1210,7 @@ export const ListSlasResponse: MessageFns<ListSlasResponse> = {
             break;
           }
 
-          message.slas.push(Sla.decode(reader, reader.uint32()));
+          message.slos.push(Slo.decode(reader, reader.uint32()));
           continue;
         }
       }
@@ -1571,62 +1222,62 @@ export const ListSlasResponse: MessageFns<ListSlasResponse> = {
     return message;
   },
 
-  fromJSON(object: any): ListSlasResponse {
+  fromJSON(object: any): ListSlosResponse {
     return {
       status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
-      slas: globalThis.Array.isArray(object?.slas) ? object.slas.map((e: any) => Sla.fromJSON(e)) : [],
+      slos: globalThis.Array.isArray(object?.slos) ? object.slos.map((e: any) => Slo.fromJSON(e)) : [],
     };
   },
 
-  toJSON(message: ListSlasResponse): unknown {
+  toJSON(message: ListSlosResponse): unknown {
     const obj: any = {};
     if (message.status !== undefined) {
       obj.status = ResponseStatus.toJSON(message.status);
     }
-    if (message.slas?.length) {
-      obj.slas = message.slas.map((e) => Sla.toJSON(e));
+    if (message.slos?.length) {
+      obj.slos = message.slos.map((e) => Slo.toJSON(e));
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<ListSlasResponse>, I>>(base?: I): ListSlasResponse {
-    return ListSlasResponse.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<ListSlosResponse>, I>>(base?: I): ListSlosResponse {
+    return ListSlosResponse.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<ListSlasResponse>, I>>(object: I): ListSlasResponse {
-    const message = createBaseListSlasResponse();
+  fromPartial<I extends Exact<DeepPartial<ListSlosResponse>, I>>(object: I): ListSlosResponse {
+    const message = createBaseListSlosResponse();
     message.status = (object.status !== undefined && object.status !== null)
       ? ResponseStatus.fromPartial(object.status)
       : undefined;
-    message.slas = object.slas?.map((e) => Sla.fromPartial(e)) || [];
+    message.slos = object.slos?.map((e) => Slo.fromPartial(e)) || [];
     return message;
   },
 };
 
-function createBaseUpdateSlaRequest(): UpdateSlaRequest {
-  return { organizationId: "", projectId: "", slaId: "", updates: undefined };
+function createBaseUpdateSloRequest(): UpdateSloRequest {
+  return { organizationId: "", projectId: "", sloId: "", updates: undefined };
 }
 
-export const UpdateSlaRequest: MessageFns<UpdateSlaRequest> = {
-  encode(message: UpdateSlaRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const UpdateSloRequest: MessageFns<UpdateSloRequest> = {
+  encode(message: UpdateSloRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.organizationId !== "") {
       writer.uint32(10).string(message.organizationId);
     }
     if (message.projectId !== "") {
       writer.uint32(18).string(message.projectId);
     }
-    if (message.slaId !== "") {
-      writer.uint32(26).string(message.slaId);
+    if (message.sloId !== "") {
+      writer.uint32(26).string(message.sloId);
     }
     if (message.updates !== undefined) {
-      UpdateSlaRequest_SlaUpdates.encode(message.updates, writer.uint32(34).fork()).join();
+      UpdateSloRequest_SloUpdates.encode(message.updates, writer.uint32(34).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): UpdateSlaRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateSloRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpdateSlaRequest();
+    const message = createBaseUpdateSloRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1651,7 +1302,7 @@ export const UpdateSlaRequest: MessageFns<UpdateSlaRequest> = {
             break;
           }
 
-          message.slaId = reader.string();
+          message.sloId = reader.string();
           continue;
         }
         case 4: {
@@ -1659,7 +1310,7 @@ export const UpdateSlaRequest: MessageFns<UpdateSlaRequest> = {
             break;
           }
 
-          message.updates = UpdateSlaRequest_SlaUpdates.decode(reader, reader.uint32());
+          message.updates = UpdateSloRequest_SloUpdates.decode(reader, reader.uint32());
           continue;
         }
       }
@@ -1671,7 +1322,7 @@ export const UpdateSlaRequest: MessageFns<UpdateSlaRequest> = {
     return message;
   },
 
-  fromJSON(object: any): UpdateSlaRequest {
+  fromJSON(object: any): UpdateSloRequest {
     return {
       organizationId: isSet(object.organizationId)
         ? globalThis.String(object.organizationId)
@@ -1683,16 +1334,16 @@ export const UpdateSlaRequest: MessageFns<UpdateSlaRequest> = {
         : isSet(object.project_id)
         ? globalThis.String(object.project_id)
         : "",
-      slaId: isSet(object.slaId)
-        ? globalThis.String(object.slaId)
-        : isSet(object.sla_id)
-        ? globalThis.String(object.sla_id)
+      sloId: isSet(object.sloId)
+        ? globalThis.String(object.sloId)
+        : isSet(object.slo_id)
+        ? globalThis.String(object.slo_id)
         : "",
-      updates: isSet(object.updates) ? UpdateSlaRequest_SlaUpdates.fromJSON(object.updates) : undefined,
+      updates: isSet(object.updates) ? UpdateSloRequest_SloUpdates.fromJSON(object.updates) : undefined,
     };
   },
 
-  toJSON(message: UpdateSlaRequest): unknown {
+  toJSON(message: UpdateSloRequest): unknown {
     const obj: any = {};
     if (message.organizationId !== "") {
       obj.organizationId = message.organizationId;
@@ -1700,36 +1351,36 @@ export const UpdateSlaRequest: MessageFns<UpdateSlaRequest> = {
     if (message.projectId !== "") {
       obj.projectId = message.projectId;
     }
-    if (message.slaId !== "") {
-      obj.slaId = message.slaId;
+    if (message.sloId !== "") {
+      obj.sloId = message.sloId;
     }
     if (message.updates !== undefined) {
-      obj.updates = UpdateSlaRequest_SlaUpdates.toJSON(message.updates);
+      obj.updates = UpdateSloRequest_SloUpdates.toJSON(message.updates);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<UpdateSlaRequest>, I>>(base?: I): UpdateSlaRequest {
-    return UpdateSlaRequest.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<UpdateSloRequest>, I>>(base?: I): UpdateSloRequest {
+    return UpdateSloRequest.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<UpdateSlaRequest>, I>>(object: I): UpdateSlaRequest {
-    const message = createBaseUpdateSlaRequest();
+  fromPartial<I extends Exact<DeepPartial<UpdateSloRequest>, I>>(object: I): UpdateSloRequest {
+    const message = createBaseUpdateSloRequest();
     message.organizationId = object.organizationId ?? "";
     message.projectId = object.projectId ?? "";
-    message.slaId = object.slaId ?? "";
+    message.sloId = object.sloId ?? "";
     message.updates = (object.updates !== undefined && object.updates !== null)
-      ? UpdateSlaRequest_SlaUpdates.fromPartial(object.updates)
+      ? UpdateSloRequest_SloUpdates.fromPartial(object.updates)
       : undefined;
     return message;
   },
 };
 
-function createBaseUpdateSlaRequest_SlaUpdates(): UpdateSlaRequest_SlaUpdates {
-  return { name: undefined, description: undefined, enabled: undefined, check: undefined };
+function createBaseUpdateSloRequest_SloUpdates(): UpdateSloRequest_SloUpdates {
+  return { name: undefined, description: undefined, enabled: undefined, objective: undefined };
 }
 
-export const UpdateSlaRequest_SlaUpdates: MessageFns<UpdateSlaRequest_SlaUpdates> = {
-  encode(message: UpdateSlaRequest_SlaUpdates, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const UpdateSloRequest_SloUpdates: MessageFns<UpdateSloRequest_SloUpdates> = {
+  encode(message: UpdateSloRequest_SloUpdates, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.name !== undefined) {
       writer.uint32(10).string(message.name);
     }
@@ -1739,16 +1390,16 @@ export const UpdateSlaRequest_SlaUpdates: MessageFns<UpdateSlaRequest_SlaUpdates
     if (message.enabled !== undefined) {
       writer.uint32(24).bool(message.enabled);
     }
-    if (message.check !== undefined) {
-      SlaCheck.encode(message.check, writer.uint32(34).fork()).join();
+    if (message.objective !== undefined) {
+      SloObjective.encode(message.objective, writer.uint32(34).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): UpdateSlaRequest_SlaUpdates {
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateSloRequest_SloUpdates {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpdateSlaRequest_SlaUpdates();
+    const message = createBaseUpdateSloRequest_SloUpdates();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1781,7 +1432,7 @@ export const UpdateSlaRequest_SlaUpdates: MessageFns<UpdateSlaRequest_SlaUpdates
             break;
           }
 
-          message.check = SlaCheck.decode(reader, reader.uint32());
+          message.objective = SloObjective.decode(reader, reader.uint32());
           continue;
         }
       }
@@ -1793,16 +1444,16 @@ export const UpdateSlaRequest_SlaUpdates: MessageFns<UpdateSlaRequest_SlaUpdates
     return message;
   },
 
-  fromJSON(object: any): UpdateSlaRequest_SlaUpdates {
+  fromJSON(object: any): UpdateSloRequest_SloUpdates {
     return {
       name: isSet(object.name) ? globalThis.String(object.name) : undefined,
       description: isSet(object.description) ? globalThis.String(object.description) : undefined,
       enabled: isSet(object.enabled) ? globalThis.Boolean(object.enabled) : undefined,
-      check: isSet(object.check) ? SlaCheck.fromJSON(object.check) : undefined,
+      objective: isSet(object.objective) ? SloObjective.fromJSON(object.objective) : undefined,
     };
   },
 
-  toJSON(message: UpdateSlaRequest_SlaUpdates): unknown {
+  toJSON(message: UpdateSloRequest_SloUpdates): unknown {
     const obj: any = {};
     if (message.name !== undefined) {
       obj.name = message.name;
@@ -1813,46 +1464,46 @@ export const UpdateSlaRequest_SlaUpdates: MessageFns<UpdateSlaRequest_SlaUpdates
     if (message.enabled !== undefined) {
       obj.enabled = message.enabled;
     }
-    if (message.check !== undefined) {
-      obj.check = SlaCheck.toJSON(message.check);
+    if (message.objective !== undefined) {
+      obj.objective = SloObjective.toJSON(message.objective);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<UpdateSlaRequest_SlaUpdates>, I>>(base?: I): UpdateSlaRequest_SlaUpdates {
-    return UpdateSlaRequest_SlaUpdates.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<UpdateSloRequest_SloUpdates>, I>>(base?: I): UpdateSloRequest_SloUpdates {
+    return UpdateSloRequest_SloUpdates.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<UpdateSlaRequest_SlaUpdates>, I>>(object: I): UpdateSlaRequest_SlaUpdates {
-    const message = createBaseUpdateSlaRequest_SlaUpdates();
+  fromPartial<I extends Exact<DeepPartial<UpdateSloRequest_SloUpdates>, I>>(object: I): UpdateSloRequest_SloUpdates {
+    const message = createBaseUpdateSloRequest_SloUpdates();
     message.name = object.name ?? undefined;
     message.description = object.description ?? undefined;
     message.enabled = object.enabled ?? undefined;
-    message.check = (object.check !== undefined && object.check !== null)
-      ? SlaCheck.fromPartial(object.check)
+    message.objective = (object.objective !== undefined && object.objective !== null)
+      ? SloObjective.fromPartial(object.objective)
       : undefined;
     return message;
   },
 };
 
-function createBaseUpdateSlaResponse(): UpdateSlaResponse {
-  return { status: undefined, sla: undefined };
+function createBaseUpdateSloResponse(): UpdateSloResponse {
+  return { status: undefined, slo: undefined };
 }
 
-export const UpdateSlaResponse: MessageFns<UpdateSlaResponse> = {
-  encode(message: UpdateSlaResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const UpdateSloResponse: MessageFns<UpdateSloResponse> = {
+  encode(message: UpdateSloResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.status !== undefined) {
       ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
     }
-    if (message.sla !== undefined) {
-      Sla.encode(message.sla, writer.uint32(18).fork()).join();
+    if (message.slo !== undefined) {
+      Slo.encode(message.slo, writer.uint32(18).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): UpdateSlaResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateSloResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseUpdateSlaResponse();
+    const message = createBaseUpdateSloResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1869,7 +1520,7 @@ export const UpdateSlaResponse: MessageFns<UpdateSlaResponse> = {
             break;
           }
 
-          message.sla = Sla.decode(reader, reader.uint32());
+          message.slo = Slo.decode(reader, reader.uint32());
           continue;
         }
       }
@@ -1881,59 +1532,59 @@ export const UpdateSlaResponse: MessageFns<UpdateSlaResponse> = {
     return message;
   },
 
-  fromJSON(object: any): UpdateSlaResponse {
+  fromJSON(object: any): UpdateSloResponse {
     return {
       status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
-      sla: isSet(object.sla) ? Sla.fromJSON(object.sla) : undefined,
+      slo: isSet(object.slo) ? Slo.fromJSON(object.slo) : undefined,
     };
   },
 
-  toJSON(message: UpdateSlaResponse): unknown {
+  toJSON(message: UpdateSloResponse): unknown {
     const obj: any = {};
     if (message.status !== undefined) {
       obj.status = ResponseStatus.toJSON(message.status);
     }
-    if (message.sla !== undefined) {
-      obj.sla = Sla.toJSON(message.sla);
+    if (message.slo !== undefined) {
+      obj.slo = Slo.toJSON(message.slo);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<UpdateSlaResponse>, I>>(base?: I): UpdateSlaResponse {
-    return UpdateSlaResponse.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<UpdateSloResponse>, I>>(base?: I): UpdateSloResponse {
+    return UpdateSloResponse.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<UpdateSlaResponse>, I>>(object: I): UpdateSlaResponse {
-    const message = createBaseUpdateSlaResponse();
+  fromPartial<I extends Exact<DeepPartial<UpdateSloResponse>, I>>(object: I): UpdateSloResponse {
+    const message = createBaseUpdateSloResponse();
     message.status = (object.status !== undefined && object.status !== null)
       ? ResponseStatus.fromPartial(object.status)
       : undefined;
-    message.sla = (object.sla !== undefined && object.sla !== null) ? Sla.fromPartial(object.sla) : undefined;
+    message.slo = (object.slo !== undefined && object.slo !== null) ? Slo.fromPartial(object.slo) : undefined;
     return message;
   },
 };
 
-function createBaseDeleteSlaRequest(): DeleteSlaRequest {
-  return { organizationId: "", projectId: "", slaId: "" };
+function createBaseDeleteSloRequest(): DeleteSloRequest {
+  return { organizationId: "", projectId: "", sloId: "" };
 }
 
-export const DeleteSlaRequest: MessageFns<DeleteSlaRequest> = {
-  encode(message: DeleteSlaRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const DeleteSloRequest: MessageFns<DeleteSloRequest> = {
+  encode(message: DeleteSloRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.organizationId !== "") {
       writer.uint32(10).string(message.organizationId);
     }
     if (message.projectId !== "") {
       writer.uint32(18).string(message.projectId);
     }
-    if (message.slaId !== "") {
-      writer.uint32(26).string(message.slaId);
+    if (message.sloId !== "") {
+      writer.uint32(26).string(message.sloId);
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): DeleteSlaRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteSloRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseDeleteSlaRequest();
+    const message = createBaseDeleteSloRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -1958,7 +1609,7 @@ export const DeleteSlaRequest: MessageFns<DeleteSlaRequest> = {
             break;
           }
 
-          message.slaId = reader.string();
+          message.sloId = reader.string();
           continue;
         }
       }
@@ -1970,7 +1621,7 @@ export const DeleteSlaRequest: MessageFns<DeleteSlaRequest> = {
     return message;
   },
 
-  fromJSON(object: any): DeleteSlaRequest {
+  fromJSON(object: any): DeleteSloRequest {
     return {
       organizationId: isSet(object.organizationId)
         ? globalThis.String(object.organizationId)
@@ -1982,15 +1633,15 @@ export const DeleteSlaRequest: MessageFns<DeleteSlaRequest> = {
         : isSet(object.project_id)
         ? globalThis.String(object.project_id)
         : "",
-      slaId: isSet(object.slaId)
-        ? globalThis.String(object.slaId)
-        : isSet(object.sla_id)
-        ? globalThis.String(object.sla_id)
+      sloId: isSet(object.sloId)
+        ? globalThis.String(object.sloId)
+        : isSet(object.slo_id)
+        ? globalThis.String(object.slo_id)
         : "",
     };
   },
 
-  toJSON(message: DeleteSlaRequest): unknown {
+  toJSON(message: DeleteSloRequest): unknown {
     const obj: any = {};
     if (message.organizationId !== "") {
       obj.organizationId = message.organizationId;
@@ -1998,40 +1649,40 @@ export const DeleteSlaRequest: MessageFns<DeleteSlaRequest> = {
     if (message.projectId !== "") {
       obj.projectId = message.projectId;
     }
-    if (message.slaId !== "") {
-      obj.slaId = message.slaId;
+    if (message.sloId !== "") {
+      obj.sloId = message.sloId;
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<DeleteSlaRequest>, I>>(base?: I): DeleteSlaRequest {
-    return DeleteSlaRequest.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<DeleteSloRequest>, I>>(base?: I): DeleteSloRequest {
+    return DeleteSloRequest.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<DeleteSlaRequest>, I>>(object: I): DeleteSlaRequest {
-    const message = createBaseDeleteSlaRequest();
+  fromPartial<I extends Exact<DeepPartial<DeleteSloRequest>, I>>(object: I): DeleteSloRequest {
+    const message = createBaseDeleteSloRequest();
     message.organizationId = object.organizationId ?? "";
     message.projectId = object.projectId ?? "";
-    message.slaId = object.slaId ?? "";
+    message.sloId = object.sloId ?? "";
     return message;
   },
 };
 
-function createBaseDeleteSlaResponse(): DeleteSlaResponse {
+function createBaseDeleteSloResponse(): DeleteSloResponse {
   return { status: undefined };
 }
 
-export const DeleteSlaResponse: MessageFns<DeleteSlaResponse> = {
-  encode(message: DeleteSlaResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const DeleteSloResponse: MessageFns<DeleteSloResponse> = {
+  encode(message: DeleteSloResponse, 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): DeleteSlaResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteSloResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseDeleteSlaResponse();
+    const message = createBaseDeleteSloResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2052,11 +1703,11 @@ export const DeleteSlaResponse: MessageFns<DeleteSlaResponse> = {
     return message;
   },
 
-  fromJSON(object: any): DeleteSlaResponse {
+  fromJSON(object: any): DeleteSloResponse {
     return { status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined };
   },
 
-  toJSON(message: DeleteSlaResponse): unknown {
+  toJSON(message: DeleteSloResponse): unknown {
     const obj: any = {};
     if (message.status !== undefined) {
       obj.status = ResponseStatus.toJSON(message.status);
@@ -2064,11 +1715,11 @@ export const DeleteSlaResponse: MessageFns<DeleteSlaResponse> = {
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<DeleteSlaResponse>, I>>(base?: I): DeleteSlaResponse {
-    return DeleteSlaResponse.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<DeleteSloResponse>, I>>(base?: I): DeleteSloResponse {
+    return DeleteSloResponse.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<DeleteSlaResponse>, I>>(object: I): DeleteSlaResponse {
-    const message = createBaseDeleteSlaResponse();
+  fromPartial<I extends Exact<DeepPartial<DeleteSloResponse>, I>>(object: I): DeleteSloResponse {
+    const message = createBaseDeleteSloResponse();
     message.status = (object.status !== undefined && object.status !== null)
       ? ResponseStatus.fromPartial(object.status)
       : undefined;
@@ -2076,52 +1727,31 @@ export const DeleteSlaResponse: MessageFns<DeleteSlaResponse> = {
   },
 };
 
-function createBaseListSlaOutcomesRequest(): ListSlaOutcomesRequest {
-  return {
-    organizationId: "",
-    projectId: "",
-    slaId: "",
-    startTime: undefined,
-    endTime: undefined,
-    outcome: 0,
-    limit: 0,
-    offset: 0,
-  };
+function createBaseGetSloStatusRequest(): GetSloStatusRequest {
+  return { organizationId: "", projectId: "", sloId: "", evaluationTime: undefined };
 }
 
-export const ListSlaOutcomesRequest: MessageFns<ListSlaOutcomesRequest> = {
-  encode(message: ListSlaOutcomesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const GetSloStatusRequest: MessageFns<GetSloStatusRequest> = {
+  encode(message: GetSloStatusRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.organizationId !== "") {
       writer.uint32(10).string(message.organizationId);
     }
     if (message.projectId !== "") {
       writer.uint32(18).string(message.projectId);
     }
-    if (message.slaId !== "") {
-      writer.uint32(26).string(message.slaId);
+    if (message.sloId !== "") {
+      writer.uint32(26).string(message.sloId);
     }
-    if (message.startTime !== undefined) {
-      Timestamp.encode(toTimestamp(message.startTime), writer.uint32(34).fork()).join();
-    }
-    if (message.endTime !== undefined) {
-      Timestamp.encode(toTimestamp(message.endTime), writer.uint32(42).fork()).join();
-    }
-    if (message.outcome !== 0) {
-      writer.uint32(48).int32(message.outcome);
-    }
-    if (message.limit !== 0) {
-      writer.uint32(56).int32(message.limit);
-    }
-    if (message.offset !== 0) {
-      writer.uint32(64).int32(message.offset);
+    if (message.evaluationTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.evaluationTime), writer.uint32(34).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): ListSlaOutcomesRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): GetSloStatusRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseListSlaOutcomesRequest();
+    const message = createBaseGetSloStatusRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2146,7 +1776,7 @@ export const ListSlaOutcomesRequest: MessageFns<ListSlaOutcomesRequest> = {
             break;
           }
 
-          message.slaId = reader.string();
+          message.sloId = reader.string();
           continue;
         }
         case 4: {
@@ -2154,39 +1784,7 @@ export const ListSlaOutcomesRequest: MessageFns<ListSlaOutcomesRequest> = {
             break;
           }
 
-          message.startTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
-          continue;
-        }
-        case 5: {
-          if (tag !== 42) {
-            break;
-          }
-
-          message.endTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
-          continue;
-        }
-        case 6: {
-          if (tag !== 48) {
-            break;
-          }
-
-          message.outcome = reader.int32() as any;
-          continue;
-        }
-        case 7: {
-          if (tag !== 56) {
-            break;
-          }
-
-          message.limit = reader.int32();
-          continue;
-        }
-        case 8: {
-          if (tag !== 64) {
-            break;
-          }
-
-          message.offset = reader.int32();
+          message.evaluationTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
           continue;
         }
       }
@@ -2198,7 +1796,7 @@ export const ListSlaOutcomesRequest: MessageFns<ListSlaOutcomesRequest> = {
     return message;
   },
 
-  fromJSON(object: any): ListSlaOutcomesRequest {
+  fromJSON(object: any): GetSloStatusRequest {
     return {
       organizationId: isSet(object.organizationId)
         ? globalThis.String(object.organizationId)
@@ -2210,28 +1808,20 @@ export const ListSlaOutcomesRequest: MessageFns<ListSlaOutcomesRequest> = {
         : isSet(object.project_id)
         ? globalThis.String(object.project_id)
         : "",
-      slaId: isSet(object.slaId)
-        ? globalThis.String(object.slaId)
-        : isSet(object.sla_id)
-        ? globalThis.String(object.sla_id)
+      sloId: isSet(object.sloId)
+        ? globalThis.String(object.sloId)
+        : isSet(object.slo_id)
+        ? globalThis.String(object.slo_id)
         : "",
-      startTime: isSet(object.startTime)
-        ? fromJsonTimestamp(object.startTime)
-        : isSet(object.start_time)
-        ? fromJsonTimestamp(object.start_time)
+      evaluationTime: isSet(object.evaluationTime)
+        ? fromJsonTimestamp(object.evaluationTime)
+        : isSet(object.evaluation_time)
+        ? fromJsonTimestamp(object.evaluation_time)
         : undefined,
-      endTime: isSet(object.endTime)
-        ? fromJsonTimestamp(object.endTime)
-        : isSet(object.end_time)
-        ? fromJsonTimestamp(object.end_time)
-        : undefined,
-      outcome: isSet(object.outcome) ? slaOutcomeStatusFromJSON(object.outcome) : 0,
-      limit: isSet(object.limit) ? globalThis.Number(object.limit) : 0,
-      offset: isSet(object.offset) ? globalThis.Number(object.offset) : 0,
     };
   },
 
-  toJSON(message: ListSlaOutcomesRequest): unknown {
+  toJSON(message: GetSloStatusRequest): unknown {
     const obj: any = {};
     if (message.organizationId !== "") {
       obj.organizationId = message.organizationId;
@@ -2239,63 +1829,47 @@ export const ListSlaOutcomesRequest: MessageFns<ListSlaOutcomesRequest> = {
     if (message.projectId !== "") {
       obj.projectId = message.projectId;
     }
-    if (message.slaId !== "") {
-      obj.slaId = message.slaId;
-    }
-    if (message.startTime !== undefined) {
-      obj.startTime = message.startTime.toISOString();
-    }
-    if (message.endTime !== undefined) {
-      obj.endTime = message.endTime.toISOString();
-    }
-    if (message.outcome !== 0) {
-      obj.outcome = slaOutcomeStatusToJSON(message.outcome);
+    if (message.sloId !== "") {
+      obj.sloId = message.sloId;
     }
-    if (message.limit !== 0) {
-      obj.limit = Math.round(message.limit);
-    }
-    if (message.offset !== 0) {
-      obj.offset = Math.round(message.offset);
+    if (message.evaluationTime !== undefined) {
+      obj.evaluationTime = message.evaluationTime.toISOString();
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<ListSlaOutcomesRequest>, I>>(base?: I): ListSlaOutcomesRequest {
-    return ListSlaOutcomesRequest.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<GetSloStatusRequest>, I>>(base?: I): GetSloStatusRequest {
+    return GetSloStatusRequest.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<ListSlaOutcomesRequest>, I>>(object: I): ListSlaOutcomesRequest {
-    const message = createBaseListSlaOutcomesRequest();
+  fromPartial<I extends Exact<DeepPartial<GetSloStatusRequest>, I>>(object: I): GetSloStatusRequest {
+    const message = createBaseGetSloStatusRequest();
     message.organizationId = object.organizationId ?? "";
     message.projectId = object.projectId ?? "";
-    message.slaId = object.slaId ?? "";
-    message.startTime = object.startTime ?? undefined;
-    message.endTime = object.endTime ?? undefined;
-    message.outcome = object.outcome ?? 0;
-    message.limit = object.limit ?? 0;
-    message.offset = object.offset ?? 0;
+    message.sloId = object.sloId ?? "";
+    message.evaluationTime = object.evaluationTime ?? undefined;
     return message;
   },
 };
 
-function createBaseListSlaOutcomesResponse(): ListSlaOutcomesResponse {
-  return { status: undefined, outcomes: [] };
+function createBaseGetSloStatusResponse(): GetSloStatusResponse {
+  return { status: undefined, sloStatus: undefined };
 }
 
-export const ListSlaOutcomesResponse: MessageFns<ListSlaOutcomesResponse> = {
-  encode(message: ListSlaOutcomesResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+export const GetSloStatusResponse: MessageFns<GetSloStatusResponse> = {
+  encode(message: GetSloStatusResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.status !== undefined) {
       ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
     }
-    for (const v of message.outcomes) {
-      SlaOutcome.encode(v!, writer.uint32(18).fork()).join();
+    if (message.sloStatus !== undefined) {
+      SloStatus.encode(message.sloStatus, writer.uint32(18).fork()).join();
     }
     return writer;
   },
 
-  decode(input: BinaryReader | Uint8Array, length?: number): ListSlaOutcomesResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): GetSloStatusResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     const end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseListSlaOutcomesResponse();
+    const message = createBaseGetSloStatusResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -2312,7 +1886,7 @@ export const ListSlaOutcomesResponse: MessageFns<ListSlaOutcomesResponse> = {
             break;
           }
 
-          message.outcomes.push(SlaOutcome.decode(reader, reader.uint32()));
+          message.sloStatus = SloStatus.decode(reader, reader.uint32());
           continue;
         }
       }
@@ -2324,97 +1898,415 @@ export const ListSlaOutcomesResponse: MessageFns<ListSlaOutcomesResponse> = {
     return message;
   },
 
-  fromJSON(object: any): ListSlaOutcomesResponse {
+  fromJSON(object: any): GetSloStatusResponse {
     return {
       status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
-      outcomes: globalThis.Array.isArray(object?.outcomes)
-        ? object.outcomes.map((e: any) => SlaOutcome.fromJSON(e))
-        : [],
+      sloStatus: isSet(object.sloStatus)
+        ? SloStatus.fromJSON(object.sloStatus)
+        : isSet(object.slo_status)
+        ? SloStatus.fromJSON(object.slo_status)
+        : undefined,
     };
   },
 
-  toJSON(message: ListSlaOutcomesResponse): unknown {
+  toJSON(message: GetSloStatusResponse): unknown {
     const obj: any = {};
     if (message.status !== undefined) {
       obj.status = ResponseStatus.toJSON(message.status);
     }
-    if (message.outcomes?.length) {
-      obj.outcomes = message.outcomes.map((e) => SlaOutcome.toJSON(e));
+    if (message.sloStatus !== undefined) {
+      obj.sloStatus = SloStatus.toJSON(message.sloStatus);
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<ListSlaOutcomesResponse>, I>>(base?: I): ListSlaOutcomesResponse {
-    return ListSlaOutcomesResponse.fromPartial(base ?? ({} as any));
+  create<I extends Exact<DeepPartial<GetSloStatusResponse>, I>>(base?: I): GetSloStatusResponse {
+    return GetSloStatusResponse.fromPartial(base ?? ({} as any));
   },
-  fromPartial<I extends Exact<DeepPartial<ListSlaOutcomesResponse>, I>>(object: I): ListSlaOutcomesResponse {
-    const message = createBaseListSlaOutcomesResponse();
+  fromPartial<I extends Exact<DeepPartial<GetSloStatusResponse>, I>>(object: I): GetSloStatusResponse {
+    const message = createBaseGetSloStatusResponse();
     message.status = (object.status !== undefined && object.status !== null)
       ? ResponseStatus.fromPartial(object.status)
       : undefined;
-    message.outcomes = object.outcomes?.map((e) => SlaOutcome.fromPartial(e)) || [];
+    message.sloStatus = (object.sloStatus !== undefined && object.sloStatus !== null)
+      ? SloStatus.fromPartial(object.sloStatus)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseSloStatus(): SloStatus {
+  return { sloId: "", enabled: false, windowSeconds: 0, windowStart: undefined, windowEnd: undefined, corridors: [] };
+}
+
+export const SloStatus: MessageFns<SloStatus> = {
+  encode(message: SloStatus, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.sloId !== "") {
+      writer.uint32(10).string(message.sloId);
+    }
+    if (message.enabled !== false) {
+      writer.uint32(16).bool(message.enabled);
+    }
+    if (message.windowSeconds !== 0) {
+      writer.uint32(24).int64(message.windowSeconds);
+    }
+    if (message.windowStart !== undefined) {
+      Timestamp.encode(toTimestamp(message.windowStart), writer.uint32(34).fork()).join();
+    }
+    if (message.windowEnd !== undefined) {
+      Timestamp.encode(toTimestamp(message.windowEnd), writer.uint32(42).fork()).join();
+    }
+    for (const v of message.corridors) {
+      SloCorridorStatus.encode(v!, writer.uint32(50).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SloStatus {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSloStatus();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.sloId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.enabled = reader.bool();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.windowSeconds = longToNumber(reader.int64());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.windowStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.windowEnd = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.corridors.push(SloCorridorStatus.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SloStatus {
+    return {
+      sloId: isSet(object.sloId)
+        ? globalThis.String(object.sloId)
+        : isSet(object.slo_id)
+        ? globalThis.String(object.slo_id)
+        : "",
+      enabled: isSet(object.enabled) ? globalThis.Boolean(object.enabled) : false,
+      windowSeconds: isSet(object.windowSeconds)
+        ? globalThis.Number(object.windowSeconds)
+        : isSet(object.window_seconds)
+        ? globalThis.Number(object.window_seconds)
+        : 0,
+      windowStart: isSet(object.windowStart)
+        ? fromJsonTimestamp(object.windowStart)
+        : isSet(object.window_start)
+        ? fromJsonTimestamp(object.window_start)
+        : undefined,
+      windowEnd: isSet(object.windowEnd)
+        ? fromJsonTimestamp(object.windowEnd)
+        : isSet(object.window_end)
+        ? fromJsonTimestamp(object.window_end)
+        : undefined,
+      corridors: globalThis.Array.isArray(object?.corridors)
+        ? object.corridors.map((e: any) => SloCorridorStatus.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: SloStatus): unknown {
+    const obj: any = {};
+    if (message.sloId !== "") {
+      obj.sloId = message.sloId;
+    }
+    if (message.enabled !== false) {
+      obj.enabled = message.enabled;
+    }
+    if (message.windowSeconds !== 0) {
+      obj.windowSeconds = Math.round(message.windowSeconds);
+    }
+    if (message.windowStart !== undefined) {
+      obj.windowStart = message.windowStart.toISOString();
+    }
+    if (message.windowEnd !== undefined) {
+      obj.windowEnd = message.windowEnd.toISOString();
+    }
+    if (message.corridors?.length) {
+      obj.corridors = message.corridors.map((e) => SloCorridorStatus.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SloStatus>, I>>(base?: I): SloStatus {
+    return SloStatus.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SloStatus>, I>>(object: I): SloStatus {
+    const message = createBaseSloStatus();
+    message.sloId = object.sloId ?? "";
+    message.enabled = object.enabled ?? false;
+    message.windowSeconds = object.windowSeconds ?? 0;
+    message.windowStart = object.windowStart ?? undefined;
+    message.windowEnd = object.windowEnd ?? undefined;
+    message.corridors = object.corridors?.map((e) => SloCorridorStatus.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSloCorridorStatus(): SloCorridorStatus {
+  return { groupValues: [], eligibleCount: 0, goodCount: 0, compliance: 0, budgetRemaining: 0, state: 0 };
+}
+
+export const SloCorridorStatus: MessageFns<SloCorridorStatus> = {
+  encode(message: SloCorridorStatus, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.groupValues) {
+      writer.uint32(10).string(v!);
+    }
+    if (message.eligibleCount !== 0) {
+      writer.uint32(16).uint64(message.eligibleCount);
+    }
+    if (message.goodCount !== 0) {
+      writer.uint32(24).uint64(message.goodCount);
+    }
+    if (message.compliance !== 0) {
+      writer.uint32(33).double(message.compliance);
+    }
+    if (message.budgetRemaining !== 0) {
+      writer.uint32(41).double(message.budgetRemaining);
+    }
+    if (message.state !== 0) {
+      writer.uint32(48).int32(message.state);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SloCorridorStatus {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSloCorridorStatus();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.groupValues.push(reader.string());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.eligibleCount = longToNumber(reader.uint64());
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.goodCount = longToNumber(reader.uint64());
+          continue;
+        }
+        case 4: {
+          if (tag !== 33) {
+            break;
+          }
+
+          message.compliance = reader.double();
+          continue;
+        }
+        case 5: {
+          if (tag !== 41) {
+            break;
+          }
+
+          message.budgetRemaining = reader.double();
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.state = reader.int32() as any;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SloCorridorStatus {
+    return {
+      groupValues: globalThis.Array.isArray(object?.groupValues)
+        ? object.groupValues.map((e: any) => globalThis.String(e))
+        : globalThis.Array.isArray(object?.group_values)
+        ? object.group_values.map((e: any) => globalThis.String(e))
+        : [],
+      eligibleCount: isSet(object.eligibleCount)
+        ? globalThis.Number(object.eligibleCount)
+        : isSet(object.eligible_count)
+        ? globalThis.Number(object.eligible_count)
+        : 0,
+      goodCount: isSet(object.goodCount)
+        ? globalThis.Number(object.goodCount)
+        : isSet(object.good_count)
+        ? globalThis.Number(object.good_count)
+        : 0,
+      compliance: isSet(object.compliance) ? globalThis.Number(object.compliance) : 0,
+      budgetRemaining: isSet(object.budgetRemaining)
+        ? globalThis.Number(object.budgetRemaining)
+        : isSet(object.budget_remaining)
+        ? globalThis.Number(object.budget_remaining)
+        : 0,
+      state: isSet(object.state) ? sloCorridorStateFromJSON(object.state) : 0,
+    };
+  },
+
+  toJSON(message: SloCorridorStatus): unknown {
+    const obj: any = {};
+    if (message.groupValues?.length) {
+      obj.groupValues = message.groupValues;
+    }
+    if (message.eligibleCount !== 0) {
+      obj.eligibleCount = Math.round(message.eligibleCount);
+    }
+    if (message.goodCount !== 0) {
+      obj.goodCount = Math.round(message.goodCount);
+    }
+    if (message.compliance !== 0) {
+      obj.compliance = message.compliance;
+    }
+    if (message.budgetRemaining !== 0) {
+      obj.budgetRemaining = message.budgetRemaining;
+    }
+    if (message.state !== 0) {
+      obj.state = sloCorridorStateToJSON(message.state);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SloCorridorStatus>, I>>(base?: I): SloCorridorStatus {
+    return SloCorridorStatus.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SloCorridorStatus>, I>>(object: I): SloCorridorStatus {
+    const message = createBaseSloCorridorStatus();
+    message.groupValues = object.groupValues?.map((e) => e) || [];
+    message.eligibleCount = object.eligibleCount ?? 0;
+    message.goodCount = object.goodCount ?? 0;
+    message.compliance = object.compliance ?? 0;
+    message.budgetRemaining = object.budgetRemaining ?? 0;
+    message.state = object.state ?? 0;
     return message;
   },
 };
 
-/** SlaGatewayService provides web client access to SLA definitions and outcomes. */
-export interface SlaGatewayService {
-  CreateSla(request: CreateSlaRequest, metadata?: Metadata): Promise<CreateSlaResponse>;
-  GetSla(request: GetSlaRequest, metadata?: Metadata): Promise<GetSlaResponse>;
-  ListSlas(request: ListSlasRequest, metadata?: Metadata): Promise<ListSlasResponse>;
-  UpdateSla(request: UpdateSlaRequest, metadata?: Metadata): Promise<UpdateSlaResponse>;
-  DeleteSla(request: DeleteSlaRequest, metadata?: Metadata): Promise<DeleteSlaResponse>;
-  ListSlaOutcomes(request: ListSlaOutcomesRequest, metadata?: Metadata): Promise<ListSlaOutcomesResponse>;
+/** SloGatewayService provides web client access to SLO definitions. */
+export interface SloGatewayService {
+  CreateSlo(request: CreateSloRequest, metadata?: Metadata): Promise<CreateSloResponse>;
+  GetSlo(request: GetSloRequest, metadata?: Metadata): Promise<GetSloResponse>;
+  ListSlos(request: ListSlosRequest, metadata?: Metadata): Promise<ListSlosResponse>;
+  UpdateSlo(request: UpdateSloRequest, metadata?: Metadata): Promise<UpdateSloResponse>;
+  DeleteSlo(request: DeleteSloRequest, metadata?: Metadata): Promise<DeleteSloResponse>;
+  GetSloStatus(request: GetSloStatusRequest, metadata?: Metadata): Promise<GetSloStatusResponse>;
 }
 
-export const SlaGatewayServiceServiceName = "gateway.web.v1.SlaGatewayService";
-export class SlaGatewayServiceClientImpl implements SlaGatewayService {
+export const SloGatewayServiceServiceName = "gateway.web.v1.SloGatewayService";
+export class SloGatewayServiceClientImpl implements SloGatewayService {
   private readonly rpc: Rpc;
   private readonly service: string;
   constructor(rpc: Rpc, opts?: { service?: string }) {
-    this.service = opts?.service || SlaGatewayServiceServiceName;
+    this.service = opts?.service || SloGatewayServiceServiceName;
     this.rpc = rpc;
-    this.CreateSla = this.CreateSla.bind(this);
-    this.GetSla = this.GetSla.bind(this);
-    this.ListSlas = this.ListSlas.bind(this);
-    this.UpdateSla = this.UpdateSla.bind(this);
-    this.DeleteSla = this.DeleteSla.bind(this);
-    this.ListSlaOutcomes = this.ListSlaOutcomes.bind(this);
+    this.CreateSlo = this.CreateSlo.bind(this);
+    this.GetSlo = this.GetSlo.bind(this);
+    this.ListSlos = this.ListSlos.bind(this);
+    this.UpdateSlo = this.UpdateSlo.bind(this);
+    this.DeleteSlo = this.DeleteSlo.bind(this);
+    this.GetSloStatus = this.GetSloStatus.bind(this);
   }
-  CreateSla(request: CreateSlaRequest, metadata?: Metadata): Promise<CreateSlaResponse> {
-    const data = CreateSlaRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "CreateSla", data, metadata);
-    return promise.then((data) => CreateSlaResponse.decode(new BinaryReader(data)));
+  CreateSlo(request: CreateSloRequest, metadata?: Metadata): Promise<CreateSloResponse> {
+    const data = CreateSloRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "CreateSlo", data, metadata);
+    return promise.then((data) => CreateSloResponse.decode(new BinaryReader(data)));
   }
 
-  GetSla(request: GetSlaRequest, metadata?: Metadata): Promise<GetSlaResponse> {
-    const data = GetSlaRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "GetSla", data, metadata);
-    return promise.then((data) => GetSlaResponse.decode(new BinaryReader(data)));
+  GetSlo(request: GetSloRequest, metadata?: Metadata): Promise<GetSloResponse> {
+    const data = GetSloRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetSlo", data, metadata);
+    return promise.then((data) => GetSloResponse.decode(new BinaryReader(data)));
   }
 
-  ListSlas(request: ListSlasRequest, metadata?: Metadata): Promise<ListSlasResponse> {
-    const data = ListSlasRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "ListSlas", data, metadata);
-    return promise.then((data) => ListSlasResponse.decode(new BinaryReader(data)));
+  ListSlos(request: ListSlosRequest, metadata?: Metadata): Promise<ListSlosResponse> {
+    const data = ListSlosRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "ListSlos", data, metadata);
+    return promise.then((data) => ListSlosResponse.decode(new BinaryReader(data)));
   }
 
-  UpdateSla(request: UpdateSlaRequest, metadata?: Metadata): Promise<UpdateSlaResponse> {
-    const data = UpdateSlaRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "UpdateSla", data, metadata);
-    return promise.then((data) => UpdateSlaResponse.decode(new BinaryReader(data)));
+  UpdateSlo(request: UpdateSloRequest, metadata?: Metadata): Promise<UpdateSloResponse> {
+    const data = UpdateSloRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "UpdateSlo", data, metadata);
+    return promise.then((data) => UpdateSloResponse.decode(new BinaryReader(data)));
   }
 
-  DeleteSla(request: DeleteSlaRequest, metadata?: Metadata): Promise<DeleteSlaResponse> {
-    const data = DeleteSlaRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "DeleteSla", data, metadata);
-    return promise.then((data) => DeleteSlaResponse.decode(new BinaryReader(data)));
+  DeleteSlo(request: DeleteSloRequest, metadata?: Metadata): Promise<DeleteSloResponse> {
+    const data = DeleteSloRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "DeleteSlo", data, metadata);
+    return promise.then((data) => DeleteSloResponse.decode(new BinaryReader(data)));
   }
 
-  ListSlaOutcomes(request: ListSlaOutcomesRequest, metadata?: Metadata): Promise<ListSlaOutcomesResponse> {
-    const data = ListSlaOutcomesRequest.encode(request).finish();
-    const promise = this.rpc.request(this.service, "ListSlaOutcomes", data, metadata);
-    return promise.then((data) => ListSlaOutcomesResponse.decode(new BinaryReader(data)));
+  GetSloStatus(request: GetSloStatusRequest, metadata?: Metadata): Promise<GetSloStatusResponse> {
+    const data = GetSloStatusRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetSloStatus", data, metadata);
+    return promise.then((data) => GetSloStatusResponse.decode(new BinaryReader(data)));
   }
 }