@miradorlabs/web-grpc 2.19.0 → 2.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miradorlabs/web-grpc",
-  "version": "2.19.0",
+  "version": "2.20.0",
   "description": "Generated gRPC (grpc-js) client stubs for the Mirador web gateway.",
   "main": "index.js",
   "types": "index.d.ts",

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

@@ -63,6 +63,51 @@ export function sloComparatorToJSON(object: SloComparator): string {
   }
 }
 
+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 sloCorridorStateFromJSON(object: any): SloCorridorState {
+  switch (object) {
+    case 0:
+    case "SLO_CORRIDOR_STATE_UNSPECIFIED":
+      return SloCorridorState.SLO_CORRIDOR_STATE_UNSPECIFIED;
+    case 1:
+    case "SLO_CORRIDOR_STATE_OK":
+      return SloCorridorState.SLO_CORRIDOR_STATE_OK;
+    case 2:
+    case "SLO_CORRIDOR_STATE_BREACHED":
+      return SloCorridorState.SLO_CORRIDOR_STATE_BREACHED;
+    case 3:
+    case "SLO_CORRIDOR_STATE_NO_DATA":
+      return SloCorridorState.SLO_CORRIDOR_STATE_NO_DATA;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return SloCorridorState.UNRECOGNIZED;
+  }
+}
+
+export function sloCorridorStateToJSON(object: SloCorridorState): string {
+  switch (object) {
+    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 Slo {
   id: string;
   organizationId: string;
@@ -161,6 +206,47 @@ export interface DeleteSloResponse {
   status: ResponseStatus | undefined;
 }
 
+export interface GetSloStatusRequest {
+  organizationId: string;
+  projectId: string;
+  sloId: string;
+  /** evaluation_time: the instant the rolling window ends at. Unset = server now(). */
+  evaluationTime: Date | undefined;
+}
+
+export interface GetSloStatusResponse {
+  status: ResponseStatus | undefined;
+  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 createBaseSlo(): Slo {
   return {
     id: "",
@@ -1641,6 +1727,528 @@ export const DeleteSloResponse: MessageFns<DeleteSloResponse> = {
   },
 };
 
+function createBaseGetSloStatusRequest(): GetSloStatusRequest {
+  return { organizationId: "", projectId: "", sloId: "", evaluationTime: undefined };
+}
+
+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.sloId !== "") {
+      writer.uint32(26).string(message.sloId);
+    }
+    if (message.evaluationTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.evaluationTime), writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+
+  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 = createBaseGetSloStatusRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.organizationId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.projectId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.sloId = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.evaluationTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetSloStatusRequest {
+    return {
+      organizationId: isSet(object.organizationId)
+        ? globalThis.String(object.organizationId)
+        : isSet(object.organization_id)
+        ? globalThis.String(object.organization_id)
+        : "",
+      projectId: isSet(object.projectId)
+        ? globalThis.String(object.projectId)
+        : isSet(object.project_id)
+        ? globalThis.String(object.project_id)
+        : "",
+      sloId: isSet(object.sloId)
+        ? globalThis.String(object.sloId)
+        : isSet(object.slo_id)
+        ? globalThis.String(object.slo_id)
+        : "",
+      evaluationTime: isSet(object.evaluationTime)
+        ? fromJsonTimestamp(object.evaluationTime)
+        : isSet(object.evaluation_time)
+        ? fromJsonTimestamp(object.evaluation_time)
+        : undefined,
+    };
+  },
+
+  toJSON(message: GetSloStatusRequest): unknown {
+    const obj: any = {};
+    if (message.organizationId !== "") {
+      obj.organizationId = message.organizationId;
+    }
+    if (message.projectId !== "") {
+      obj.projectId = message.projectId;
+    }
+    if (message.sloId !== "") {
+      obj.sloId = message.sloId;
+    }
+    if (message.evaluationTime !== undefined) {
+      obj.evaluationTime = message.evaluationTime.toISOString();
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetSloStatusRequest>, I>>(base?: I): GetSloStatusRequest {
+    return GetSloStatusRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetSloStatusRequest>, I>>(object: I): GetSloStatusRequest {
+    const message = createBaseGetSloStatusRequest();
+    message.organizationId = object.organizationId ?? "";
+    message.projectId = object.projectId ?? "";
+    message.sloId = object.sloId ?? "";
+    message.evaluationTime = object.evaluationTime ?? undefined;
+    return message;
+  },
+};
+
+function createBaseGetSloStatusResponse(): GetSloStatusResponse {
+  return { status: undefined, sloStatus: undefined };
+}
+
+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();
+    }
+    if (message.sloStatus !== undefined) {
+      SloStatus.encode(message.sloStatus, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  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 = createBaseGetSloStatusResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.status = ResponseStatus.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.sloStatus = SloStatus.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetSloStatusResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      sloStatus: isSet(object.sloStatus)
+        ? SloStatus.fromJSON(object.sloStatus)
+        : isSet(object.slo_status)
+        ? SloStatus.fromJSON(object.slo_status)
+        : undefined,
+    };
+  },
+
+  toJSON(message: GetSloStatusResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.sloStatus !== undefined) {
+      obj.sloStatus = SloStatus.toJSON(message.sloStatus);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetSloStatusResponse>, I>>(base?: I): GetSloStatusResponse {
+    return GetSloStatusResponse.fromPartial(base ?? ({} as any));
+  },
+  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.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;
+  },
+};
+
 /** SloGatewayService provides web client access to SLO definitions. */
 export interface SloGatewayService {
   CreateSlo(request: CreateSloRequest, metadata?: Metadata): Promise<CreateSloResponse>;
@@ -1648,6 +2256,7 @@ export interface SloGatewayService {
   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 SloGatewayServiceServiceName = "gateway.web.v1.SloGatewayService";
@@ -1662,6 +2271,7 @@ export class SloGatewayServiceClientImpl implements SloGatewayService {
     this.ListSlos = this.ListSlos.bind(this);
     this.UpdateSlo = this.UpdateSlo.bind(this);
     this.DeleteSlo = this.DeleteSlo.bind(this);
+    this.GetSloStatus = this.GetSloStatus.bind(this);
   }
   CreateSlo(request: CreateSloRequest, metadata?: Metadata): Promise<CreateSloResponse> {
     const data = CreateSloRequest.encode(request).finish();
@@ -1692,6 +2302,12 @@ export class SloGatewayServiceClientImpl implements SloGatewayService {
     const promise = this.rpc.request(this.service, "DeleteSlo", data, metadata);
     return promise.then((data) => DeleteSloResponse.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)));
+  }
 }
 
 interface Rpc {

package/proto/gateway/web/v1/slo_gateway_grpc_pb.js

@@ -72,6 +72,28 @@ function deserialize_gateway_web_v1_GetSloResponse(buffer_arg) {
   return proto_gateway_web_v1_slo_gateway_pb.GetSloResponse.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_gateway_web_v1_GetSloStatusRequest(arg) {
+  if (!(arg instanceof proto_gateway_web_v1_slo_gateway_pb.GetSloStatusRequest)) {
+    throw new Error('Expected argument of type gateway.web.v1.GetSloStatusRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gateway_web_v1_GetSloStatusRequest(buffer_arg) {
+  return proto_gateway_web_v1_slo_gateway_pb.GetSloStatusRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_gateway_web_v1_GetSloStatusResponse(arg) {
+  if (!(arg instanceof proto_gateway_web_v1_slo_gateway_pb.GetSloStatusResponse)) {
+    throw new Error('Expected argument of type gateway.web.v1.GetSloStatusResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gateway_web_v1_GetSloStatusResponse(buffer_arg) {
+  return proto_gateway_web_v1_slo_gateway_pb.GetSloStatusResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_gateway_web_v1_ListSlosRequest(arg) {
   if (!(arg instanceof proto_gateway_web_v1_slo_gateway_pb.ListSlosRequest)) {
     throw new Error('Expected argument of type gateway.web.v1.ListSlosRequest');
@@ -174,6 +196,17 @@ var SloGatewayServiceService = exports.SloGatewayServiceService = {
     responseSerialize: serialize_gateway_web_v1_DeleteSloResponse,
     responseDeserialize: deserialize_gateway_web_v1_DeleteSloResponse,
   },
+  getSloStatus: {
+    path: '/gateway.web.v1.SloGatewayService/GetSloStatus',
+    requestStream: false,
+    responseStream: false,
+    requestType: proto_gateway_web_v1_slo_gateway_pb.GetSloStatusRequest,
+    responseType: proto_gateway_web_v1_slo_gateway_pb.GetSloStatusResponse,
+    requestSerialize: serialize_gateway_web_v1_GetSloStatusRequest,
+    requestDeserialize: deserialize_gateway_web_v1_GetSloStatusRequest,
+    responseSerialize: serialize_gateway_web_v1_GetSloStatusResponse,
+    responseDeserialize: deserialize_gateway_web_v1_GetSloStatusResponse,
+  },
 };
 
 exports.SloGatewayServiceClient = grpc.makeGenericClientConstructor(SloGatewayServiceService, 'SloGatewayService');