@cerbos/grpc/src/protobuf/grpc/health/v1/health.ts

Client library for interacting with the Cerbos policy decision point service over gRPC from server-side Node.js applications

// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// source: grpc/health/v1/health.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import {
  type CallOptions,
  type ChannelCredentials,
  Client,
  type ClientOptions,
  type ClientReadableStream,
  type ClientUnaryCall,
  type handleServerStreamingCall,
  type handleUnaryCall,
  makeGenericClientConstructor,
  type Metadata,
  type ServiceError,
  type UntypedServiceImplementation,
} from "@grpc/grpc-js";

export const protobufPackage = "grpc.health.v1";

export interface HealthCheckRequest {
  service: string;
}

export interface HealthCheckResponse {
  status: HealthCheckResponse_ServingStatus;
}

export enum HealthCheckResponse_ServingStatus {
  UNKNOWN = 0,
  SERVING = 1,
  NOT_SERVING = 2,
  SERVICE_UNKNOWN = 3,
}

export interface HealthListRequest {}

export interface HealthListResponse {
  statuses: { [key: string]: HealthCheckResponse };
}

export interface HealthListResponse_StatusesEntry {
  key: string;
  value: HealthCheckResponse | undefined;
}

function createBaseHealthCheckRequest(): HealthCheckRequest {
  return { service: "" };
}

export const HealthCheckRequest: MessageFns<HealthCheckRequest> = {
  encode(
    message: HealthCheckRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.service !== "") {
      writer.uint32(10).string(message.service);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): HealthCheckRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseHealthCheckRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.service = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseHealthCheckResponse(): HealthCheckResponse {
  return { status: 0 };
}

export const HealthCheckResponse: MessageFns<HealthCheckResponse> = {
  encode(
    message: HealthCheckResponse,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.status !== 0) {
      writer.uint32(8).int32(message.status);
    }
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): HealthCheckResponse {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseHealthCheckResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.status = reader.int32() as any;
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseHealthListRequest(): HealthListRequest {
  return {};
}

export const HealthListRequest: MessageFns<HealthListRequest> = {
  encode(
    _: HealthListRequest,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): HealthListRequest {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseHealthListRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseHealthListResponse(): HealthListResponse {
  return { statuses: {} };
}

export const HealthListResponse: MessageFns<HealthListResponse> = {
  encode(
    message: HealthListResponse,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    Object.entries(message.statuses).forEach(([key, value]) => {
      HealthListResponse_StatusesEntry.encode(
        { key: key as any, value },
        writer.uint32(10).fork(),
      ).join();
    });
    return writer;
  },

  decode(
    input: BinaryReader | Uint8Array,
    length?: number,
  ): HealthListResponse {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseHealthListResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }

          const entry1 = HealthListResponse_StatusesEntry.decode(
            reader,
            reader.uint32(),
          );
          if (entry1.value !== undefined) {
            message.statuses[entry1.key] = entry1.value;
          }
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseHealthListResponse_StatusesEntry(): HealthListResponse_StatusesEntry {
  return { key: "", value: undefined };
}

export const HealthListResponse_StatusesEntry: MessageFns<HealthListResponse_StatusesEntry> =
  {
    encode(
      message: HealthListResponse_StatusesEntry,
      writer: BinaryWriter = new BinaryWriter(),
    ): BinaryWriter {
      if (message.key !== "") {
        writer.uint32(10).string(message.key);
      }
      if (message.value !== undefined) {
        HealthCheckResponse.encode(
          message.value,
          writer.uint32(18).fork(),
        ).join();
      }
      return writer;
    },

    decode(
      input: BinaryReader | Uint8Array,
      length?: number,
    ): HealthListResponse_StatusesEntry {
      const reader =
        input instanceof BinaryReader ? input : new BinaryReader(input);
      const end = length === undefined ? reader.len : reader.pos + length;
      const message = createBaseHealthListResponse_StatusesEntry();
      while (reader.pos < end) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }

            message.key = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }

            message.value = HealthCheckResponse.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
  };

export type HealthService = typeof HealthService;
export const HealthService = {
  check: {
    path: "/grpc.health.v1.Health/Check",
    requestStream: false,
    responseStream: false,
    requestSerialize: (value: HealthCheckRequest): Buffer =>
      Buffer.from(HealthCheckRequest.encode(value).finish()),
    requestDeserialize: (value: Buffer): HealthCheckRequest =>
      HealthCheckRequest.decode(value),
    responseSerialize: (value: HealthCheckResponse): Buffer =>
      Buffer.from(HealthCheckResponse.encode(value).finish()),
    responseDeserialize: (value: Buffer): HealthCheckResponse =>
      HealthCheckResponse.decode(value),
  },
  list: {
    path: "/grpc.health.v1.Health/List",
    requestStream: false,
    responseStream: false,
    requestSerialize: (value: HealthListRequest): Buffer =>
      Buffer.from(HealthListRequest.encode(value).finish()),
    requestDeserialize: (value: Buffer): HealthListRequest =>
      HealthListRequest.decode(value),
    responseSerialize: (value: HealthListResponse): Buffer =>
      Buffer.from(HealthListResponse.encode(value).finish()),
    responseDeserialize: (value: Buffer): HealthListResponse =>
      HealthListResponse.decode(value),
  },
  watch: {
    path: "/grpc.health.v1.Health/Watch",
    requestStream: false,
    responseStream: true,
    requestSerialize: (value: HealthCheckRequest): Buffer =>
      Buffer.from(HealthCheckRequest.encode(value).finish()),
    requestDeserialize: (value: Buffer): HealthCheckRequest =>
      HealthCheckRequest.decode(value),
    responseSerialize: (value: HealthCheckResponse): Buffer =>
      Buffer.from(HealthCheckResponse.encode(value).finish()),
    responseDeserialize: (value: Buffer): HealthCheckResponse =>
      HealthCheckResponse.decode(value),
  },
} as const;

export interface HealthServer extends UntypedServiceImplementation {
  check: handleUnaryCall<HealthCheckRequest, HealthCheckResponse>;
  list: handleUnaryCall<HealthListRequest, HealthListResponse>;
  watch: handleServerStreamingCall<HealthCheckRequest, HealthCheckResponse>;
}

export interface HealthClient extends Client {
  check(
    request: HealthCheckRequest,
    callback: (
      error: ServiceError | null,
      response: HealthCheckResponse,
    ) => void,
  ): ClientUnaryCall;
  check(
    request: HealthCheckRequest,
    metadata: Metadata,
    callback: (
      error: ServiceError | null,
      response: HealthCheckResponse,
    ) => void,
  ): ClientUnaryCall;
  check(
    request: HealthCheckRequest,
    metadata: Metadata,
    options: Partial<CallOptions>,
    callback: (
      error: ServiceError | null,
      response: HealthCheckResponse,
    ) => void,
  ): ClientUnaryCall;
  list(
    request: HealthListRequest,
    callback: (
      error: ServiceError | null,
      response: HealthListResponse,
    ) => void,
  ): ClientUnaryCall;
  list(
    request: HealthListRequest,
    metadata: Metadata,
    callback: (
      error: ServiceError | null,
      response: HealthListResponse,
    ) => void,
  ): ClientUnaryCall;
  list(
    request: HealthListRequest,
    metadata: Metadata,
    options: Partial<CallOptions>,
    callback: (
      error: ServiceError | null,
      response: HealthListResponse,
    ) => void,
  ): ClientUnaryCall;
  watch(
    request: HealthCheckRequest,
    options?: Partial<CallOptions>,
  ): ClientReadableStream<HealthCheckResponse>;
  watch(
    request: HealthCheckRequest,
    metadata?: Metadata,
    options?: Partial<CallOptions>,
  ): ClientReadableStream<HealthCheckResponse>;
}

export const HealthClient = makeGenericClientConstructor(
  HealthService,
  "grpc.health.v1.Health",
) as unknown as {
  new (
    address: string,
    credentials: ChannelCredentials,
    options?: Partial<ClientOptions>,
  ): HealthClient;
  service: typeof HealthService;
  serviceName: string;
};

export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
}