@miradorlabs/web-grpc 2.20.0 → 2.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miradorlabs/web-grpc",
-  "version": "2.20.0",
+  "version": "2.21.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

@@ -247,6 +247,46 @@ export interface SloCorridorStatus {
   state: SloCorridorState;
 }
 
+export interface GetSloTimelineRequest {
+  organizationId: string;
+  projectId: string;
+  sloId: string;
+  /** end_time: the timeline's right edge; truncated down to the UTC hour. Unset = now(). */
+  endTime:
+    | Date
+    | undefined;
+  /** bucket_count: number of trailing 1-hour buckets (0 = default 168 = 7d; max 2000). */
+  bucketCount: number;
+}
+
+export interface GetSloTimelineResponse {
+  status: ResponseStatus | undefined;
+  timeline: SloTimeline | undefined;
+}
+
+/**
+ * SloTimeline is one SLO's per-hour health over a trailing window of completed UTC
+ * hours. Buckets are SPARSE: an hour with no eligible sample is omitted (render it
+ * no-data). Each bucket is the worst (lowest-compliance) corridor that hour.
+ */
+export interface SloTimeline {
+  sloId: string;
+  enabled: boolean;
+  target: number;
+  bucketSeconds: number;
+  windowStart: Date | undefined;
+  windowEnd: Date | undefined;
+  buckets: SloTimelineBucket[];
+}
+
+export interface SloTimelineBucket {
+  bucketStart: Date | undefined;
+  eligibleCount: number;
+  goodCount: number;
+  compliance: number;
+  state: SloCorridorState;
+}
+
 function createBaseSlo(): Slo {
   return {
     id: "",
@@ -2249,6 +2289,548 @@ export const SloCorridorStatus: MessageFns<SloCorridorStatus> = {
   },
 };
 
+function createBaseGetSloTimelineRequest(): GetSloTimelineRequest {
+  return { organizationId: "", projectId: "", sloId: "", endTime: undefined, bucketCount: 0 };
+}
+
+export const GetSloTimelineRequest: MessageFns<GetSloTimelineRequest> = {
+  encode(message: GetSloTimelineRequest, 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.endTime !== undefined) {
+      Timestamp.encode(toTimestamp(message.endTime), writer.uint32(34).fork()).join();
+    }
+    if (message.bucketCount !== 0) {
+      writer.uint32(40).uint32(message.bucketCount);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetSloTimelineRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetSloTimelineRequest();
+    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.endTime = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.bucketCount = reader.uint32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetSloTimelineRequest {
+    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)
+        : "",
+      endTime: isSet(object.endTime)
+        ? fromJsonTimestamp(object.endTime)
+        : isSet(object.end_time)
+        ? fromJsonTimestamp(object.end_time)
+        : undefined,
+      bucketCount: isSet(object.bucketCount)
+        ? globalThis.Number(object.bucketCount)
+        : isSet(object.bucket_count)
+        ? globalThis.Number(object.bucket_count)
+        : 0,
+    };
+  },
+
+  toJSON(message: GetSloTimelineRequest): 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.endTime !== undefined) {
+      obj.endTime = message.endTime.toISOString();
+    }
+    if (message.bucketCount !== 0) {
+      obj.bucketCount = Math.round(message.bucketCount);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetSloTimelineRequest>, I>>(base?: I): GetSloTimelineRequest {
+    return GetSloTimelineRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetSloTimelineRequest>, I>>(object: I): GetSloTimelineRequest {
+    const message = createBaseGetSloTimelineRequest();
+    message.organizationId = object.organizationId ?? "";
+    message.projectId = object.projectId ?? "";
+    message.sloId = object.sloId ?? "";
+    message.endTime = object.endTime ?? undefined;
+    message.bucketCount = object.bucketCount ?? 0;
+    return message;
+  },
+};
+
+function createBaseGetSloTimelineResponse(): GetSloTimelineResponse {
+  return { status: undefined, timeline: undefined };
+}
+
+export const GetSloTimelineResponse: MessageFns<GetSloTimelineResponse> = {
+  encode(message: GetSloTimelineResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.status !== undefined) {
+      ResponseStatus.encode(message.status, writer.uint32(10).fork()).join();
+    }
+    if (message.timeline !== undefined) {
+      SloTimeline.encode(message.timeline, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): GetSloTimelineResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetSloTimelineResponse();
+    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.timeline = SloTimeline.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetSloTimelineResponse {
+    return {
+      status: isSet(object.status) ? ResponseStatus.fromJSON(object.status) : undefined,
+      timeline: isSet(object.timeline) ? SloTimeline.fromJSON(object.timeline) : undefined,
+    };
+  },
+
+  toJSON(message: GetSloTimelineResponse): unknown {
+    const obj: any = {};
+    if (message.status !== undefined) {
+      obj.status = ResponseStatus.toJSON(message.status);
+    }
+    if (message.timeline !== undefined) {
+      obj.timeline = SloTimeline.toJSON(message.timeline);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetSloTimelineResponse>, I>>(base?: I): GetSloTimelineResponse {
+    return GetSloTimelineResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetSloTimelineResponse>, I>>(object: I): GetSloTimelineResponse {
+    const message = createBaseGetSloTimelineResponse();
+    message.status = (object.status !== undefined && object.status !== null)
+      ? ResponseStatus.fromPartial(object.status)
+      : undefined;
+    message.timeline = (object.timeline !== undefined && object.timeline !== null)
+      ? SloTimeline.fromPartial(object.timeline)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseSloTimeline(): SloTimeline {
+  return {
+    sloId: "",
+    enabled: false,
+    target: 0,
+    bucketSeconds: 0,
+    windowStart: undefined,
+    windowEnd: undefined,
+    buckets: [],
+  };
+}
+
+export const SloTimeline: MessageFns<SloTimeline> = {
+  encode(message: SloTimeline, 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.target !== 0) {
+      writer.uint32(25).double(message.target);
+    }
+    if (message.bucketSeconds !== 0) {
+      writer.uint32(32).int64(message.bucketSeconds);
+    }
+    if (message.windowStart !== undefined) {
+      Timestamp.encode(toTimestamp(message.windowStart), writer.uint32(42).fork()).join();
+    }
+    if (message.windowEnd !== undefined) {
+      Timestamp.encode(toTimestamp(message.windowEnd), writer.uint32(50).fork()).join();
+    }
+    for (const v of message.buckets) {
+      SloTimelineBucket.encode(v!, writer.uint32(58).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SloTimeline {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSloTimeline();
+    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 !== 25) {
+            break;
+          }
+
+          message.target = reader.double();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.bucketSeconds = longToNumber(reader.int64());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.windowStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.windowEnd = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.buckets.push(SloTimelineBucket.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SloTimeline {
+    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,
+      target: isSet(object.target) ? globalThis.Number(object.target) : 0,
+      bucketSeconds: isSet(object.bucketSeconds)
+        ? globalThis.Number(object.bucketSeconds)
+        : isSet(object.bucket_seconds)
+        ? globalThis.Number(object.bucket_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,
+      buckets: globalThis.Array.isArray(object?.buckets)
+        ? object.buckets.map((e: any) => SloTimelineBucket.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: SloTimeline): unknown {
+    const obj: any = {};
+    if (message.sloId !== "") {
+      obj.sloId = message.sloId;
+    }
+    if (message.enabled !== false) {
+      obj.enabled = message.enabled;
+    }
+    if (message.target !== 0) {
+      obj.target = message.target;
+    }
+    if (message.bucketSeconds !== 0) {
+      obj.bucketSeconds = Math.round(message.bucketSeconds);
+    }
+    if (message.windowStart !== undefined) {
+      obj.windowStart = message.windowStart.toISOString();
+    }
+    if (message.windowEnd !== undefined) {
+      obj.windowEnd = message.windowEnd.toISOString();
+    }
+    if (message.buckets?.length) {
+      obj.buckets = message.buckets.map((e) => SloTimelineBucket.toJSON(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SloTimeline>, I>>(base?: I): SloTimeline {
+    return SloTimeline.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SloTimeline>, I>>(object: I): SloTimeline {
+    const message = createBaseSloTimeline();
+    message.sloId = object.sloId ?? "";
+    message.enabled = object.enabled ?? false;
+    message.target = object.target ?? 0;
+    message.bucketSeconds = object.bucketSeconds ?? 0;
+    message.windowStart = object.windowStart ?? undefined;
+    message.windowEnd = object.windowEnd ?? undefined;
+    message.buckets = object.buckets?.map((e) => SloTimelineBucket.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSloTimelineBucket(): SloTimelineBucket {
+  return { bucketStart: undefined, eligibleCount: 0, goodCount: 0, compliance: 0, state: 0 };
+}
+
+export const SloTimelineBucket: MessageFns<SloTimelineBucket> = {
+  encode(message: SloTimelineBucket, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.bucketStart !== undefined) {
+      Timestamp.encode(toTimestamp(message.bucketStart), writer.uint32(10).fork()).join();
+    }
+    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.state !== 0) {
+      writer.uint32(40).int32(message.state);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SloTimelineBucket {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSloTimelineBucket();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.bucketStart = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          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 !== 40) {
+            break;
+          }
+
+          message.state = reader.int32() as any;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SloTimelineBucket {
+    return {
+      bucketStart: isSet(object.bucketStart)
+        ? fromJsonTimestamp(object.bucketStart)
+        : isSet(object.bucket_start)
+        ? fromJsonTimestamp(object.bucket_start)
+        : undefined,
+      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,
+      state: isSet(object.state) ? sloCorridorStateFromJSON(object.state) : 0,
+    };
+  },
+
+  toJSON(message: SloTimelineBucket): unknown {
+    const obj: any = {};
+    if (message.bucketStart !== undefined) {
+      obj.bucketStart = message.bucketStart.toISOString();
+    }
+    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.state !== 0) {
+      obj.state = sloCorridorStateToJSON(message.state);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<SloTimelineBucket>, I>>(base?: I): SloTimelineBucket {
+    return SloTimelineBucket.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<SloTimelineBucket>, I>>(object: I): SloTimelineBucket {
+    const message = createBaseSloTimelineBucket();
+    message.bucketStart = object.bucketStart ?? undefined;
+    message.eligibleCount = object.eligibleCount ?? 0;
+    message.goodCount = object.goodCount ?? 0;
+    message.compliance = object.compliance ?? 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>;
@@ -2257,6 +2839,7 @@ export interface SloGatewayService {
   UpdateSlo(request: UpdateSloRequest, metadata?: Metadata): Promise<UpdateSloResponse>;
   DeleteSlo(request: DeleteSloRequest, metadata?: Metadata): Promise<DeleteSloResponse>;
   GetSloStatus(request: GetSloStatusRequest, metadata?: Metadata): Promise<GetSloStatusResponse>;
+  GetSloTimeline(request: GetSloTimelineRequest, metadata?: Metadata): Promise<GetSloTimelineResponse>;
 }
 
 export const SloGatewayServiceServiceName = "gateway.web.v1.SloGatewayService";
@@ -2272,6 +2855,7 @@ export class SloGatewayServiceClientImpl implements SloGatewayService {
     this.UpdateSlo = this.UpdateSlo.bind(this);
     this.DeleteSlo = this.DeleteSlo.bind(this);
     this.GetSloStatus = this.GetSloStatus.bind(this);
+    this.GetSloTimeline = this.GetSloTimeline.bind(this);
   }
   CreateSlo(request: CreateSloRequest, metadata?: Metadata): Promise<CreateSloResponse> {
     const data = CreateSloRequest.encode(request).finish();
@@ -2308,6 +2892,12 @@ export class SloGatewayServiceClientImpl implements SloGatewayService {
     const promise = this.rpc.request(this.service, "GetSloStatus", data, metadata);
     return promise.then((data) => GetSloStatusResponse.decode(new BinaryReader(data)));
   }
+
+  GetSloTimeline(request: GetSloTimelineRequest, metadata?: Metadata): Promise<GetSloTimelineResponse> {
+    const data = GetSloTimelineRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "GetSloTimeline", data, metadata);
+    return promise.then((data) => GetSloTimelineResponse.decode(new BinaryReader(data)));
+  }
 }
 
 interface Rpc {

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

@@ -94,6 +94,28 @@ 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_GetSloTimelineRequest(arg) {
+  if (!(arg instanceof proto_gateway_web_v1_slo_gateway_pb.GetSloTimelineRequest)) {
+    throw new Error('Expected argument of type gateway.web.v1.GetSloTimelineRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gateway_web_v1_GetSloTimelineRequest(buffer_arg) {
+  return proto_gateway_web_v1_slo_gateway_pb.GetSloTimelineRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_gateway_web_v1_GetSloTimelineResponse(arg) {
+  if (!(arg instanceof proto_gateway_web_v1_slo_gateway_pb.GetSloTimelineResponse)) {
+    throw new Error('Expected argument of type gateway.web.v1.GetSloTimelineResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_gateway_web_v1_GetSloTimelineResponse(buffer_arg) {
+  return proto_gateway_web_v1_slo_gateway_pb.GetSloTimelineResponse.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');
@@ -207,6 +229,17 @@ var SloGatewayServiceService = exports.SloGatewayServiceService = {
     responseSerialize: serialize_gateway_web_v1_GetSloStatusResponse,
     responseDeserialize: deserialize_gateway_web_v1_GetSloStatusResponse,
   },
+  getSloTimeline: {
+    path: '/gateway.web.v1.SloGatewayService/GetSloTimeline',
+    requestStream: false,
+    responseStream: false,
+    requestType: proto_gateway_web_v1_slo_gateway_pb.GetSloTimelineRequest,
+    responseType: proto_gateway_web_v1_slo_gateway_pb.GetSloTimelineResponse,
+    requestSerialize: serialize_gateway_web_v1_GetSloTimelineRequest,
+    requestDeserialize: deserialize_gateway_web_v1_GetSloTimelineRequest,
+    responseSerialize: serialize_gateway_web_v1_GetSloTimelineResponse,
+    responseDeserialize: deserialize_gateway_web_v1_GetSloTimelineResponse,
+  },
 };
 
 exports.SloGatewayServiceClient = grpc.makeGenericClientConstructor(SloGatewayServiceService, 'SloGatewayService');