// @generated by protoc-gen-es v1.8.0 with parameter "target=ts"
// @generated from file service/v1alpha1/service.proto (package akuity.io.kargo.service.v1alpha1, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, Timestamp } from "@bufbuild/protobuf";
import { Freight, Project, Promotion, Stage, Warehouse } from "../../v1alpha1/generated_pb.js";
import { ConfigMap, Event, Secret } from "../../k8s.io/api/core/v1/generated_pb.js";
import { AnalysisRun, AnalysisTemplate } from "../../rollouts/api/v1alpha1/generated_pb.js";
import { Claim, ResourceDetails, Role, RoleResources } from "../../rbac/v1alpha1/generated_pb.js";

/**
 * @generated from enum akuity.io.kargo.service.v1alpha1.RawFormat
 */
export enum RawFormat {
  /**
   * @generated from enum value: RAW_FORMAT_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

  /**
   * @generated from enum value: RAW_FORMAT_JSON = 1;
   */
  JSON = 1,

  /**
   * @generated from enum value: RAW_FORMAT_YAML = 2;
   */
  YAML = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(RawFormat)
proto3.util.setEnumType(RawFormat, "akuity.io.kargo.service.v1alpha1.RawFormat", [
  { no: 0, name: "RAW_FORMAT_UNSPECIFIED" },
  { no: 1, name: "RAW_FORMAT_JSON" },
  { no: 2, name: "RAW_FORMAT_YAML" },
]);

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ComponentVersions
 */
export class ComponentVersions extends Message<ComponentVersions> {
  /**
   * @generated from field: optional akuity.io.kargo.service.v1alpha1.VersionInfo server = 1;
   */
  server?: VersionInfo;

  /**
   * @generated from field: optional akuity.io.kargo.service.v1alpha1.VersionInfo cli = 2;
   */
  cli?: VersionInfo;

  constructor(data?: PartialMessage<ComponentVersions>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ComponentVersions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "server", kind: "message", T: VersionInfo, opt: true },
    { no: 2, name: "cli", kind: "message", T: VersionInfo, opt: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ComponentVersions {
    return new ComponentVersions().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ComponentVersions {
    return new ComponentVersions().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ComponentVersions {
    return new ComponentVersions().fromJsonString(jsonString, options);
  }

  static equals(a: ComponentVersions | PlainMessage<ComponentVersions> | undefined, b: ComponentVersions | PlainMessage<ComponentVersions> | undefined): boolean {
    return proto3.util.equals(ComponentVersions, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.VersionInfo
 */
export class VersionInfo extends Message<VersionInfo> {
  /**
   * @generated from field: string version = 1;
   */
  version = "";

  /**
   * @generated from field: string git_commit = 2;
   */
  gitCommit = "";

  /**
   * @generated from field: bool git_tree_dirty = 3;
   */
  gitTreeDirty = false;

  /**
   * @generated from field: google.protobuf.Timestamp build_time = 4;
   */
  buildTime?: Timestamp;

  /**
   * @generated from field: string go_version = 5;
   */
  goVersion = "";

  /**
   * @generated from field: string compiler = 6;
   */
  compiler = "";

  /**
   * @generated from field: string platform = 7;
   */
  platform = "";

  constructor(data?: PartialMessage<VersionInfo>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.VersionInfo";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "git_commit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "git_tree_dirty", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 4, name: "build_time", kind: "message", T: Timestamp },
    { no: 5, name: "go_version", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "compiler", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "platform", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VersionInfo {
    return new VersionInfo().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VersionInfo {
    return new VersionInfo().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VersionInfo {
    return new VersionInfo().fromJsonString(jsonString, options);
  }

  static equals(a: VersionInfo | PlainMessage<VersionInfo> | undefined, b: VersionInfo | PlainMessage<VersionInfo> | undefined): boolean {
    return proto3.util.equals(VersionInfo, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetVersionInfoRequest
 */
export class GetVersionInfoRequest extends Message<GetVersionInfoRequest> {
  constructor(data?: PartialMessage<GetVersionInfoRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetVersionInfoRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetVersionInfoRequest {
    return new GetVersionInfoRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetVersionInfoRequest {
    return new GetVersionInfoRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetVersionInfoRequest {
    return new GetVersionInfoRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetVersionInfoRequest | PlainMessage<GetVersionInfoRequest> | undefined, b: GetVersionInfoRequest | PlainMessage<GetVersionInfoRequest> | undefined): boolean {
    return proto3.util.equals(GetVersionInfoRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetVersionInfoResponse
 */
export class GetVersionInfoResponse extends Message<GetVersionInfoResponse> {
  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.VersionInfo version_info = 1;
   */
  versionInfo?: VersionInfo;

  constructor(data?: PartialMessage<GetVersionInfoResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetVersionInfoResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "version_info", kind: "message", T: VersionInfo },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetVersionInfoResponse {
    return new GetVersionInfoResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetVersionInfoResponse {
    return new GetVersionInfoResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetVersionInfoResponse {
    return new GetVersionInfoResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetVersionInfoResponse | PlainMessage<GetVersionInfoResponse> | undefined, b: GetVersionInfoResponse | PlainMessage<GetVersionInfoResponse> | undefined): boolean {
    return proto3.util.equals(GetVersionInfoResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetConfigRequest
 */
export class GetConfigRequest extends Message<GetConfigRequest> {
  constructor(data?: PartialMessage<GetConfigRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetConfigRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetConfigRequest {
    return new GetConfigRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetConfigRequest {
    return new GetConfigRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetConfigRequest {
    return new GetConfigRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetConfigRequest | PlainMessage<GetConfigRequest> | undefined, b: GetConfigRequest | PlainMessage<GetConfigRequest> | undefined): boolean {
    return proto3.util.equals(GetConfigRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ArgoCDShard
 */
export class ArgoCDShard extends Message<ArgoCDShard> {
  /**
   * @generated from field: string url = 1;
   */
  url = "";

  /**
   * @generated from field: string namespace = 2;
   */
  namespace = "";

  constructor(data?: PartialMessage<ArgoCDShard>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ArgoCDShard";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "namespace", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ArgoCDShard {
    return new ArgoCDShard().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ArgoCDShard {
    return new ArgoCDShard().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ArgoCDShard {
    return new ArgoCDShard().fromJsonString(jsonString, options);
  }

  static equals(a: ArgoCDShard | PlainMessage<ArgoCDShard> | undefined, b: ArgoCDShard | PlainMessage<ArgoCDShard> | undefined): boolean {
    return proto3.util.equals(ArgoCDShard, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetConfigResponse
 */
export class GetConfigResponse extends Message<GetConfigResponse> {
  /**
   * @generated from field: map<string, akuity.io.kargo.service.v1alpha1.ArgoCDShard> argocd_shards = 1;
   */
  argocdShards: { [key: string]: ArgoCDShard } = {};

  /**
   * @generated from field: bool secret_management_enabled = 2;
   */
  secretManagementEnabled = false;

  constructor(data?: PartialMessage<GetConfigResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetConfigResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "argocd_shards", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: ArgoCDShard} },
    { no: 2, name: "secret_management_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetConfigResponse {
    return new GetConfigResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetConfigResponse {
    return new GetConfigResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetConfigResponse {
    return new GetConfigResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetConfigResponse | PlainMessage<GetConfigResponse> | undefined, b: GetConfigResponse | PlainMessage<GetConfigResponse> | undefined): boolean {
    return proto3.util.equals(GetConfigResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetPublicConfigRequest
 */
export class GetPublicConfigRequest extends Message<GetPublicConfigRequest> {
  constructor(data?: PartialMessage<GetPublicConfigRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetPublicConfigRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetPublicConfigRequest {
    return new GetPublicConfigRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetPublicConfigRequest {
    return new GetPublicConfigRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetPublicConfigRequest {
    return new GetPublicConfigRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetPublicConfigRequest | PlainMessage<GetPublicConfigRequest> | undefined, b: GetPublicConfigRequest | PlainMessage<GetPublicConfigRequest> | undefined): boolean {
    return proto3.util.equals(GetPublicConfigRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetPublicConfigResponse
 */
export class GetPublicConfigResponse extends Message<GetPublicConfigResponse> {
  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.OIDCConfig oidc_config = 1;
   */
  oidcConfig?: OIDCConfig;

  /**
   * @generated from field: bool admin_account_enabled = 2;
   */
  adminAccountEnabled = false;

  /**
   * @generated from field: bool skip_auth = 3;
   */
  skipAuth = false;

  constructor(data?: PartialMessage<GetPublicConfigResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetPublicConfigResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "oidc_config", kind: "message", T: OIDCConfig },
    { no: 2, name: "admin_account_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 3, name: "skip_auth", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetPublicConfigResponse {
    return new GetPublicConfigResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetPublicConfigResponse {
    return new GetPublicConfigResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetPublicConfigResponse {
    return new GetPublicConfigResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetPublicConfigResponse | PlainMessage<GetPublicConfigResponse> | undefined, b: GetPublicConfigResponse | PlainMessage<GetPublicConfigResponse> | undefined): boolean {
    return proto3.util.equals(GetPublicConfigResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.OIDCConfig
 */
export class OIDCConfig extends Message<OIDCConfig> {
  /**
   * @generated from field: string issuer_url = 1;
   */
  issuerUrl = "";

  /**
   * @generated from field: string client_id = 2;
   */
  clientId = "";

  /**
   * @generated from field: repeated string scopes = 3;
   */
  scopes: string[] = [];

  /**
   * @generated from field: string cli_client_id = 4;
   */
  cliClientId = "";

  constructor(data?: PartialMessage<OIDCConfig>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.OIDCConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "issuer_url", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "scopes", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 4, name: "cli_client_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): OIDCConfig {
    return new OIDCConfig().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): OIDCConfig {
    return new OIDCConfig().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): OIDCConfig {
    return new OIDCConfig().fromJsonString(jsonString, options);
  }

  static equals(a: OIDCConfig | PlainMessage<OIDCConfig> | undefined, b: OIDCConfig | PlainMessage<OIDCConfig> | undefined): boolean {
    return proto3.util.equals(OIDCConfig, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.AdminLoginRequest
 */
export class AdminLoginRequest extends Message<AdminLoginRequest> {
  /**
   * @generated from field: string password = 1;
   */
  password = "";

  constructor(data?: PartialMessage<AdminLoginRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.AdminLoginRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "password", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AdminLoginRequest {
    return new AdminLoginRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AdminLoginRequest {
    return new AdminLoginRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AdminLoginRequest {
    return new AdminLoginRequest().fromJsonString(jsonString, options);
  }

  static equals(a: AdminLoginRequest | PlainMessage<AdminLoginRequest> | undefined, b: AdminLoginRequest | PlainMessage<AdminLoginRequest> | undefined): boolean {
    return proto3.util.equals(AdminLoginRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.AdminLoginResponse
 */
export class AdminLoginResponse extends Message<AdminLoginResponse> {
  /**
   * @generated from field: string id_token = 1;
   */
  idToken = "";

  constructor(data?: PartialMessage<AdminLoginResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.AdminLoginResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id_token", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AdminLoginResponse {
    return new AdminLoginResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AdminLoginResponse {
    return new AdminLoginResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AdminLoginResponse {
    return new AdminLoginResponse().fromJsonString(jsonString, options);
  }

  static equals(a: AdminLoginResponse | PlainMessage<AdminLoginResponse> | undefined, b: AdminLoginResponse | PlainMessage<AdminLoginResponse> | undefined): boolean {
    return proto3.util.equals(AdminLoginResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.CreateResourceRequest
 */
export class CreateResourceRequest extends Message<CreateResourceRequest> {
  /**
   * @generated from field: bytes manifest = 1;
   */
  manifest = new Uint8Array(0);

  constructor(data?: PartialMessage<CreateResourceRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.CreateResourceRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "manifest", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateResourceRequest {
    return new CreateResourceRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateResourceRequest {
    return new CreateResourceRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateResourceRequest {
    return new CreateResourceRequest().fromJsonString(jsonString, options);
  }

  static equals(a: CreateResourceRequest | PlainMessage<CreateResourceRequest> | undefined, b: CreateResourceRequest | PlainMessage<CreateResourceRequest> | undefined): boolean {
    return proto3.util.equals(CreateResourceRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.CreateResourceResult
 */
export class CreateResourceResult extends Message<CreateResourceResult> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.CreateResourceResult.result
   */
  result: {
    /**
     * @generated from field: bytes created_resource_manifest = 1;
     */
    value: Uint8Array;
    case: "createdResourceManifest";
  } | {
    /**
     * @generated from field: string error = 2;
     */
    value: string;
    case: "error";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<CreateResourceResult>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.CreateResourceResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "created_resource_manifest", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
    { no: 2, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateResourceResult {
    return new CreateResourceResult().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateResourceResult {
    return new CreateResourceResult().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateResourceResult {
    return new CreateResourceResult().fromJsonString(jsonString, options);
  }

  static equals(a: CreateResourceResult | PlainMessage<CreateResourceResult> | undefined, b: CreateResourceResult | PlainMessage<CreateResourceResult> | undefined): boolean {
    return proto3.util.equals(CreateResourceResult, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.CreateResourceResponse
 */
export class CreateResourceResponse extends Message<CreateResourceResponse> {
  /**
   * @generated from field: repeated akuity.io.kargo.service.v1alpha1.CreateResourceResult results = 1;
   */
  results: CreateResourceResult[] = [];

  constructor(data?: PartialMessage<CreateResourceResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.CreateResourceResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "results", kind: "message", T: CreateResourceResult, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateResourceResponse {
    return new CreateResourceResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateResourceResponse {
    return new CreateResourceResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateResourceResponse {
    return new CreateResourceResponse().fromJsonString(jsonString, options);
  }

  static equals(a: CreateResourceResponse | PlainMessage<CreateResourceResponse> | undefined, b: CreateResourceResponse | PlainMessage<CreateResourceResponse> | undefined): boolean {
    return proto3.util.equals(CreateResourceResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.CreateOrUpdateResourceRequest
 */
export class CreateOrUpdateResourceRequest extends Message<CreateOrUpdateResourceRequest> {
  /**
   * @generated from field: bytes manifest = 1;
   */
  manifest = new Uint8Array(0);

  constructor(data?: PartialMessage<CreateOrUpdateResourceRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.CreateOrUpdateResourceRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "manifest", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateOrUpdateResourceRequest {
    return new CreateOrUpdateResourceRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateOrUpdateResourceRequest {
    return new CreateOrUpdateResourceRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateOrUpdateResourceRequest {
    return new CreateOrUpdateResourceRequest().fromJsonString(jsonString, options);
  }

  static equals(a: CreateOrUpdateResourceRequest | PlainMessage<CreateOrUpdateResourceRequest> | undefined, b: CreateOrUpdateResourceRequest | PlainMessage<CreateOrUpdateResourceRequest> | undefined): boolean {
    return proto3.util.equals(CreateOrUpdateResourceRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.CreateOrUpdateResourceResult
 */
export class CreateOrUpdateResourceResult extends Message<CreateOrUpdateResourceResult> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.CreateOrUpdateResourceResult.result
   */
  result: {
    /**
     * @generated from field: bytes created_resource_manifest = 1;
     */
    value: Uint8Array;
    case: "createdResourceManifest";
  } | {
    /**
     * @generated from field: bytes updated_resource_manifest = 2;
     */
    value: Uint8Array;
    case: "updatedResourceManifest";
  } | {
    /**
     * @generated from field: string error = 3;
     */
    value: string;
    case: "error";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<CreateOrUpdateResourceResult>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.CreateOrUpdateResourceResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "created_resource_manifest", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
    { no: 2, name: "updated_resource_manifest", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
    { no: 3, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateOrUpdateResourceResult {
    return new CreateOrUpdateResourceResult().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateOrUpdateResourceResult {
    return new CreateOrUpdateResourceResult().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateOrUpdateResourceResult {
    return new CreateOrUpdateResourceResult().fromJsonString(jsonString, options);
  }

  static equals(a: CreateOrUpdateResourceResult | PlainMessage<CreateOrUpdateResourceResult> | undefined, b: CreateOrUpdateResourceResult | PlainMessage<CreateOrUpdateResourceResult> | undefined): boolean {
    return proto3.util.equals(CreateOrUpdateResourceResult, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.CreateOrUpdateResourceResponse
 */
export class CreateOrUpdateResourceResponse extends Message<CreateOrUpdateResourceResponse> {
  /**
   * @generated from field: repeated akuity.io.kargo.service.v1alpha1.CreateOrUpdateResourceResult results = 1;
   */
  results: CreateOrUpdateResourceResult[] = [];

  constructor(data?: PartialMessage<CreateOrUpdateResourceResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.CreateOrUpdateResourceResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "results", kind: "message", T: CreateOrUpdateResourceResult, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateOrUpdateResourceResponse {
    return new CreateOrUpdateResourceResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateOrUpdateResourceResponse {
    return new CreateOrUpdateResourceResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateOrUpdateResourceResponse {
    return new CreateOrUpdateResourceResponse().fromJsonString(jsonString, options);
  }

  static equals(a: CreateOrUpdateResourceResponse | PlainMessage<CreateOrUpdateResourceResponse> | undefined, b: CreateOrUpdateResourceResponse | PlainMessage<CreateOrUpdateResourceResponse> | undefined): boolean {
    return proto3.util.equals(CreateOrUpdateResourceResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.UpdateResourceRequest
 */
export class UpdateResourceRequest extends Message<UpdateResourceRequest> {
  /**
   * @generated from field: bytes manifest = 1;
   */
  manifest = new Uint8Array(0);

  constructor(data?: PartialMessage<UpdateResourceRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.UpdateResourceRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "manifest", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateResourceRequest {
    return new UpdateResourceRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateResourceRequest {
    return new UpdateResourceRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateResourceRequest {
    return new UpdateResourceRequest().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateResourceRequest | PlainMessage<UpdateResourceRequest> | undefined, b: UpdateResourceRequest | PlainMessage<UpdateResourceRequest> | undefined): boolean {
    return proto3.util.equals(UpdateResourceRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.UpdateResourceResult
 */
export class UpdateResourceResult extends Message<UpdateResourceResult> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.UpdateResourceResult.result
   */
  result: {
    /**
     * @generated from field: bytes updated_resource_manifest = 1;
     */
    value: Uint8Array;
    case: "updatedResourceManifest";
  } | {
    /**
     * @generated from field: string error = 2;
     */
    value: string;
    case: "error";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<UpdateResourceResult>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.UpdateResourceResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "updated_resource_manifest", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
    { no: 2, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateResourceResult {
    return new UpdateResourceResult().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateResourceResult {
    return new UpdateResourceResult().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateResourceResult {
    return new UpdateResourceResult().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateResourceResult | PlainMessage<UpdateResourceResult> | undefined, b: UpdateResourceResult | PlainMessage<UpdateResourceResult> | undefined): boolean {
    return proto3.util.equals(UpdateResourceResult, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.UpdateResourceResponse
 */
export class UpdateResourceResponse extends Message<UpdateResourceResponse> {
  /**
   * @generated from field: repeated akuity.io.kargo.service.v1alpha1.UpdateResourceResult results = 1;
   */
  results: UpdateResourceResult[] = [];

  constructor(data?: PartialMessage<UpdateResourceResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.UpdateResourceResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "results", kind: "message", T: UpdateResourceResult, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateResourceResponse {
    return new UpdateResourceResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateResourceResponse {
    return new UpdateResourceResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateResourceResponse {
    return new UpdateResourceResponse().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateResourceResponse | PlainMessage<UpdateResourceResponse> | undefined, b: UpdateResourceResponse | PlainMessage<UpdateResourceResponse> | undefined): boolean {
    return proto3.util.equals(UpdateResourceResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteResourceRequest
 */
export class DeleteResourceRequest extends Message<DeleteResourceRequest> {
  /**
   * @generated from field: bytes manifest = 1;
   */
  manifest = new Uint8Array(0);

  constructor(data?: PartialMessage<DeleteResourceRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteResourceRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "manifest", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteResourceRequest {
    return new DeleteResourceRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteResourceRequest {
    return new DeleteResourceRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteResourceRequest {
    return new DeleteResourceRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteResourceRequest | PlainMessage<DeleteResourceRequest> | undefined, b: DeleteResourceRequest | PlainMessage<DeleteResourceRequest> | undefined): boolean {
    return proto3.util.equals(DeleteResourceRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteResourceResult
 */
export class DeleteResourceResult extends Message<DeleteResourceResult> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.DeleteResourceResult.result
   */
  result: {
    /**
     * @generated from field: bytes deleted_resource_manifest = 1;
     */
    value: Uint8Array;
    case: "deletedResourceManifest";
  } | {
    /**
     * @generated from field: string error = 2;
     */
    value: string;
    case: "error";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<DeleteResourceResult>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteResourceResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "deleted_resource_manifest", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
    { no: 2, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteResourceResult {
    return new DeleteResourceResult().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteResourceResult {
    return new DeleteResourceResult().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteResourceResult {
    return new DeleteResourceResult().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteResourceResult | PlainMessage<DeleteResourceResult> | undefined, b: DeleteResourceResult | PlainMessage<DeleteResourceResult> | undefined): boolean {
    return proto3.util.equals(DeleteResourceResult, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteResourceResponse
 */
export class DeleteResourceResponse extends Message<DeleteResourceResponse> {
  /**
   * @generated from field: repeated akuity.io.kargo.service.v1alpha1.DeleteResourceResult results = 1;
   */
  results: DeleteResourceResult[] = [];

  constructor(data?: PartialMessage<DeleteResourceResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteResourceResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "results", kind: "message", T: DeleteResourceResult, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteResourceResponse {
    return new DeleteResourceResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteResourceResponse {
    return new DeleteResourceResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteResourceResponse {
    return new DeleteResourceResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteResourceResponse | PlainMessage<DeleteResourceResponse> | undefined, b: DeleteResourceResponse | PlainMessage<DeleteResourceResponse> | undefined): boolean {
    return proto3.util.equals(DeleteResourceResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListStagesRequest
 */
export class ListStagesRequest extends Message<ListStagesRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  constructor(data?: PartialMessage<ListStagesRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListStagesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListStagesRequest {
    return new ListStagesRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListStagesRequest {
    return new ListStagesRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListStagesRequest {
    return new ListStagesRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListStagesRequest | PlainMessage<ListStagesRequest> | undefined, b: ListStagesRequest | PlainMessage<ListStagesRequest> | undefined): boolean {
    return proto3.util.equals(ListStagesRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListStagesResponse
 */
export class ListStagesResponse extends Message<ListStagesResponse> {
  /**
   * @generated from field: repeated github.com.akuity.kargo.api.v1alpha1.Stage stages = 1;
   */
  stages: Stage[] = [];

  constructor(data?: PartialMessage<ListStagesResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListStagesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "stages", kind: "message", T: Stage, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListStagesResponse {
    return new ListStagesResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListStagesResponse {
    return new ListStagesResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListStagesResponse {
    return new ListStagesResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListStagesResponse | PlainMessage<ListStagesResponse> | undefined, b: ListStagesResponse | PlainMessage<ListStagesResponse> | undefined): boolean {
    return proto3.util.equals(ListStagesResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListImagesRequest
 */
export class ListImagesRequest extends Message<ListImagesRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  constructor(data?: PartialMessage<ListImagesRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListImagesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListImagesRequest {
    return new ListImagesRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListImagesRequest {
    return new ListImagesRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListImagesRequest {
    return new ListImagesRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListImagesRequest | PlainMessage<ListImagesRequest> | undefined, b: ListImagesRequest | PlainMessage<ListImagesRequest> | undefined): boolean {
    return proto3.util.equals(ListImagesRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListImagesResponse
 */
export class ListImagesResponse extends Message<ListImagesResponse> {
  /**
   * images maps image repository names to their tags
   *
   * @generated from field: map<string, akuity.io.kargo.service.v1alpha1.TagMap> images = 2;
   */
  images: { [key: string]: TagMap } = {};

  constructor(data?: PartialMessage<ListImagesResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListImagesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 2, name: "images", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: TagMap} },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListImagesResponse {
    return new ListImagesResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListImagesResponse {
    return new ListImagesResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListImagesResponse {
    return new ListImagesResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListImagesResponse | PlainMessage<ListImagesResponse> | undefined, b: ListImagesResponse | PlainMessage<ListImagesResponse> | undefined): boolean {
    return proto3.util.equals(ListImagesResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.TagMap
 */
export class TagMap extends Message<TagMap> {
  /**
   * tags maps image tag names to stages which have previously used that tag
   *
   * @generated from field: map<string, akuity.io.kargo.service.v1alpha1.ImageStageMap> tags = 1;
   */
  tags: { [key: string]: ImageStageMap } = {};

  constructor(data?: PartialMessage<TagMap>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.TagMap";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "tags", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: ImageStageMap} },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TagMap {
    return new TagMap().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TagMap {
    return new TagMap().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TagMap {
    return new TagMap().fromJsonString(jsonString, options);
  }

  static equals(a: TagMap | PlainMessage<TagMap> | undefined, b: TagMap | PlainMessage<TagMap> | undefined): boolean {
    return proto3.util.equals(TagMap, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ImageStageMap
 */
export class ImageStageMap extends Message<ImageStageMap> {
  /**
   * stages maps stage names to the order which an image was promoted to that stage
   *
   * @generated from field: map<string, int32> stages = 1;
   */
  stages: { [key: string]: number } = {};

  constructor(data?: PartialMessage<ImageStageMap>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ImageStageMap";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "stages", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "scalar", T: 5 /* ScalarType.INT32 */} },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ImageStageMap {
    return new ImageStageMap().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ImageStageMap {
    return new ImageStageMap().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ImageStageMap {
    return new ImageStageMap().fromJsonString(jsonString, options);
  }

  static equals(a: ImageStageMap | PlainMessage<ImageStageMap> | undefined, b: ImageStageMap | PlainMessage<ImageStageMap> | undefined): boolean {
    return proto3.util.equals(ImageStageMap, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetStageRequest
 */
export class GetStageRequest extends Message<GetStageRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 3;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetStageRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetStageRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetStageRequest {
    return new GetStageRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetStageRequest {
    return new GetStageRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetStageRequest {
    return new GetStageRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetStageRequest | PlainMessage<GetStageRequest> | undefined, b: GetStageRequest | PlainMessage<GetStageRequest> | undefined): boolean {
    return proto3.util.equals(GetStageRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetStageResponse
 */
export class GetStageResponse extends Message<GetStageResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetStageResponse.result
   */
  result: {
    /**
     * @generated from field: github.com.akuity.kargo.api.v1alpha1.Stage stage = 1;
     */
    value: Stage;
    case: "stage";
  } | {
    /**
     * @generated from field: bytes raw = 2;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetStageResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetStageResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "stage", kind: "message", T: Stage, oneof: "result" },
    { no: 2, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetStageResponse {
    return new GetStageResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetStageResponse {
    return new GetStageResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetStageResponse {
    return new GetStageResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetStageResponse | PlainMessage<GetStageResponse> | undefined, b: GetStageResponse | PlainMessage<GetStageResponse> | undefined): boolean {
    return proto3.util.equals(GetStageResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.WatchStagesRequest
 */
export class WatchStagesRequest extends Message<WatchStagesRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<WatchStagesRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.WatchStagesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WatchStagesRequest {
    return new WatchStagesRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WatchStagesRequest {
    return new WatchStagesRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WatchStagesRequest {
    return new WatchStagesRequest().fromJsonString(jsonString, options);
  }

  static equals(a: WatchStagesRequest | PlainMessage<WatchStagesRequest> | undefined, b: WatchStagesRequest | PlainMessage<WatchStagesRequest> | undefined): boolean {
    return proto3.util.equals(WatchStagesRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.WatchStagesResponse
 */
export class WatchStagesResponse extends Message<WatchStagesResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.v1alpha1.Stage stage = 1;
   */
  stage?: Stage;

  /**
   * @generated from field: string type = 2;
   */
  type = "";

  constructor(data?: PartialMessage<WatchStagesResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.WatchStagesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "stage", kind: "message", T: Stage },
    { no: 2, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WatchStagesResponse {
    return new WatchStagesResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WatchStagesResponse {
    return new WatchStagesResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WatchStagesResponse {
    return new WatchStagesResponse().fromJsonString(jsonString, options);
  }

  static equals(a: WatchStagesResponse | PlainMessage<WatchStagesResponse> | undefined, b: WatchStagesResponse | PlainMessage<WatchStagesResponse> | undefined): boolean {
    return proto3.util.equals(WatchStagesResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteStageRequest
 */
export class DeleteStageRequest extends Message<DeleteStageRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<DeleteStageRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteStageRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteStageRequest {
    return new DeleteStageRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteStageRequest {
    return new DeleteStageRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteStageRequest {
    return new DeleteStageRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteStageRequest | PlainMessage<DeleteStageRequest> | undefined, b: DeleteStageRequest | PlainMessage<DeleteStageRequest> | undefined): boolean {
    return proto3.util.equals(DeleteStageRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteStageResponse
 */
export class DeleteStageResponse extends Message<DeleteStageResponse> {
  constructor(data?: PartialMessage<DeleteStageResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteStageResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteStageResponse {
    return new DeleteStageResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteStageResponse {
    return new DeleteStageResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteStageResponse {
    return new DeleteStageResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteStageResponse | PlainMessage<DeleteStageResponse> | undefined, b: DeleteStageResponse | PlainMessage<DeleteStageResponse> | undefined): boolean {
    return proto3.util.equals(DeleteStageResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.RefreshStageRequest
 */
export class RefreshStageRequest extends Message<RefreshStageRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<RefreshStageRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.RefreshStageRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RefreshStageRequest {
    return new RefreshStageRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RefreshStageRequest {
    return new RefreshStageRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RefreshStageRequest {
    return new RefreshStageRequest().fromJsonString(jsonString, options);
  }

  static equals(a: RefreshStageRequest | PlainMessage<RefreshStageRequest> | undefined, b: RefreshStageRequest | PlainMessage<RefreshStageRequest> | undefined): boolean {
    return proto3.util.equals(RefreshStageRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.RefreshStageResponse
 */
export class RefreshStageResponse extends Message<RefreshStageResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.v1alpha1.Stage stage = 1;
   */
  stage?: Stage;

  constructor(data?: PartialMessage<RefreshStageResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.RefreshStageResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "stage", kind: "message", T: Stage },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RefreshStageResponse {
    return new RefreshStageResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RefreshStageResponse {
    return new RefreshStageResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RefreshStageResponse {
    return new RefreshStageResponse().fromJsonString(jsonString, options);
  }

  static equals(a: RefreshStageResponse | PlainMessage<RefreshStageResponse> | undefined, b: RefreshStageResponse | PlainMessage<RefreshStageResponse> | undefined): boolean {
    return proto3.util.equals(RefreshStageResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListPromotionsRequest
 */
export class ListPromotionsRequest extends Message<ListPromotionsRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: optional string stage = 2;
   */
  stage?: string;

  constructor(data?: PartialMessage<ListPromotionsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListPromotionsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "stage", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListPromotionsRequest {
    return new ListPromotionsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListPromotionsRequest {
    return new ListPromotionsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListPromotionsRequest {
    return new ListPromotionsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListPromotionsRequest | PlainMessage<ListPromotionsRequest> | undefined, b: ListPromotionsRequest | PlainMessage<ListPromotionsRequest> | undefined): boolean {
    return proto3.util.equals(ListPromotionsRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListPromotionsResponse
 */
export class ListPromotionsResponse extends Message<ListPromotionsResponse> {
  /**
   * @generated from field: repeated github.com.akuity.kargo.api.v1alpha1.Promotion promotions = 1;
   */
  promotions: Promotion[] = [];

  constructor(data?: PartialMessage<ListPromotionsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListPromotionsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "promotions", kind: "message", T: Promotion, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListPromotionsResponse {
    return new ListPromotionsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListPromotionsResponse {
    return new ListPromotionsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListPromotionsResponse {
    return new ListPromotionsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListPromotionsResponse | PlainMessage<ListPromotionsResponse> | undefined, b: ListPromotionsResponse | PlainMessage<ListPromotionsResponse> | undefined): boolean {
    return proto3.util.equals(ListPromotionsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.WatchPromotionsRequest
 */
export class WatchPromotionsRequest extends Message<WatchPromotionsRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: optional string stage = 2;
   */
  stage?: string;

  constructor(data?: PartialMessage<WatchPromotionsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.WatchPromotionsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "stage", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WatchPromotionsRequest {
    return new WatchPromotionsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WatchPromotionsRequest {
    return new WatchPromotionsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WatchPromotionsRequest {
    return new WatchPromotionsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: WatchPromotionsRequest | PlainMessage<WatchPromotionsRequest> | undefined, b: WatchPromotionsRequest | PlainMessage<WatchPromotionsRequest> | undefined): boolean {
    return proto3.util.equals(WatchPromotionsRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.WatchPromotionsResponse
 */
export class WatchPromotionsResponse extends Message<WatchPromotionsResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.v1alpha1.Promotion promotion = 1;
   */
  promotion?: Promotion;

  /**
   * @generated from field: string type = 2;
   */
  type = "";

  constructor(data?: PartialMessage<WatchPromotionsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.WatchPromotionsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "promotion", kind: "message", T: Promotion },
    { no: 2, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WatchPromotionsResponse {
    return new WatchPromotionsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WatchPromotionsResponse {
    return new WatchPromotionsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WatchPromotionsResponse {
    return new WatchPromotionsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: WatchPromotionsResponse | PlainMessage<WatchPromotionsResponse> | undefined, b: WatchPromotionsResponse | PlainMessage<WatchPromotionsResponse> | undefined): boolean {
    return proto3.util.equals(WatchPromotionsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetPromotionRequest
 */
export class GetPromotionRequest extends Message<GetPromotionRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 3;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetPromotionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetPromotionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetPromotionRequest {
    return new GetPromotionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetPromotionRequest {
    return new GetPromotionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetPromotionRequest {
    return new GetPromotionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetPromotionRequest | PlainMessage<GetPromotionRequest> | undefined, b: GetPromotionRequest | PlainMessage<GetPromotionRequest> | undefined): boolean {
    return proto3.util.equals(GetPromotionRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetPromotionResponse
 */
export class GetPromotionResponse extends Message<GetPromotionResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetPromotionResponse.result
   */
  result: {
    /**
     * @generated from field: github.com.akuity.kargo.api.v1alpha1.Promotion promotion = 1;
     */
    value: Promotion;
    case: "promotion";
  } | {
    /**
     * @generated from field: bytes raw = 2;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetPromotionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetPromotionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "promotion", kind: "message", T: Promotion, oneof: "result" },
    { no: 2, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetPromotionResponse {
    return new GetPromotionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetPromotionResponse {
    return new GetPromotionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetPromotionResponse {
    return new GetPromotionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetPromotionResponse | PlainMessage<GetPromotionResponse> | undefined, b: GetPromotionResponse | PlainMessage<GetPromotionResponse> | undefined): boolean {
    return proto3.util.equals(GetPromotionResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.WatchPromotionRequest
 */
export class WatchPromotionRequest extends Message<WatchPromotionRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<WatchPromotionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.WatchPromotionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WatchPromotionRequest {
    return new WatchPromotionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WatchPromotionRequest {
    return new WatchPromotionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WatchPromotionRequest {
    return new WatchPromotionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: WatchPromotionRequest | PlainMessage<WatchPromotionRequest> | undefined, b: WatchPromotionRequest | PlainMessage<WatchPromotionRequest> | undefined): boolean {
    return proto3.util.equals(WatchPromotionRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.WatchPromotionResponse
 */
export class WatchPromotionResponse extends Message<WatchPromotionResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.v1alpha1.Promotion promotion = 1;
   */
  promotion?: Promotion;

  /**
   * @generated from field: string type = 2;
   */
  type = "";

  constructor(data?: PartialMessage<WatchPromotionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.WatchPromotionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "promotion", kind: "message", T: Promotion },
    { no: 2, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WatchPromotionResponse {
    return new WatchPromotionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WatchPromotionResponse {
    return new WatchPromotionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WatchPromotionResponse {
    return new WatchPromotionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: WatchPromotionResponse | PlainMessage<WatchPromotionResponse> | undefined, b: WatchPromotionResponse | PlainMessage<WatchPromotionResponse> | undefined): boolean {
    return proto3.util.equals(WatchPromotionResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.AbortPromotionRequest
 */
export class AbortPromotionRequest extends Message<AbortPromotionRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<AbortPromotionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.AbortPromotionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AbortPromotionRequest {
    return new AbortPromotionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AbortPromotionRequest {
    return new AbortPromotionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AbortPromotionRequest {
    return new AbortPromotionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: AbortPromotionRequest | PlainMessage<AbortPromotionRequest> | undefined, b: AbortPromotionRequest | PlainMessage<AbortPromotionRequest> | undefined): boolean {
    return proto3.util.equals(AbortPromotionRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.AbortPromotionResponse
 */
export class AbortPromotionResponse extends Message<AbortPromotionResponse> {
  constructor(data?: PartialMessage<AbortPromotionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.AbortPromotionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AbortPromotionResponse {
    return new AbortPromotionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AbortPromotionResponse {
    return new AbortPromotionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AbortPromotionResponse {
    return new AbortPromotionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: AbortPromotionResponse | PlainMessage<AbortPromotionResponse> | undefined, b: AbortPromotionResponse | PlainMessage<AbortPromotionResponse> | undefined): boolean {
    return proto3.util.equals(AbortPromotionResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteProjectRequest
 */
export class DeleteProjectRequest extends Message<DeleteProjectRequest> {
  /**
   * @generated from field: string name = 1;
   */
  name = "";

  constructor(data?: PartialMessage<DeleteProjectRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteProjectRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteProjectRequest {
    return new DeleteProjectRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteProjectRequest {
    return new DeleteProjectRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteProjectRequest {
    return new DeleteProjectRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteProjectRequest | PlainMessage<DeleteProjectRequest> | undefined, b: DeleteProjectRequest | PlainMessage<DeleteProjectRequest> | undefined): boolean {
    return proto3.util.equals(DeleteProjectRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteProjectResponse
 */
export class DeleteProjectResponse extends Message<DeleteProjectResponse> {
  constructor(data?: PartialMessage<DeleteProjectResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteProjectResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteProjectResponse {
    return new DeleteProjectResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteProjectResponse {
    return new DeleteProjectResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteProjectResponse {
    return new DeleteProjectResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteProjectResponse | PlainMessage<DeleteProjectResponse> | undefined, b: DeleteProjectResponse | PlainMessage<DeleteProjectResponse> | undefined): boolean {
    return proto3.util.equals(DeleteProjectResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetProjectRequest
 */
export class GetProjectRequest extends Message<GetProjectRequest> {
  /**
   * @generated from field: string name = 1;
   */
  name = "";

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 2;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetProjectRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetProjectRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetProjectRequest {
    return new GetProjectRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetProjectRequest {
    return new GetProjectRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetProjectRequest {
    return new GetProjectRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetProjectRequest | PlainMessage<GetProjectRequest> | undefined, b: GetProjectRequest | PlainMessage<GetProjectRequest> | undefined): boolean {
    return proto3.util.equals(GetProjectRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetProjectResponse
 */
export class GetProjectResponse extends Message<GetProjectResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetProjectResponse.result
   */
  result: {
    /**
     * @generated from field: github.com.akuity.kargo.api.v1alpha1.Project project = 1;
     */
    value: Project;
    case: "project";
  } | {
    /**
     * @generated from field: bytes raw = 2;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetProjectResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetProjectResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "message", T: Project, oneof: "result" },
    { no: 2, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetProjectResponse {
    return new GetProjectResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetProjectResponse {
    return new GetProjectResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetProjectResponse {
    return new GetProjectResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetProjectResponse | PlainMessage<GetProjectResponse> | undefined, b: GetProjectResponse | PlainMessage<GetProjectResponse> | undefined): boolean {
    return proto3.util.equals(GetProjectResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListProjectsRequest
 */
export class ListProjectsRequest extends Message<ListProjectsRequest> {
  /**
   * @generated from field: optional int32 page_size = 1;
   */
  pageSize?: number;

  /**
   * @generated from field: optional int32 page = 2;
   */
  page?: number;

  /**
   * @generated from field: optional string filter = 3;
   */
  filter?: string;

  constructor(data?: PartialMessage<ListProjectsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListProjectsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "page_size", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
    { no: 2, name: "page", kind: "scalar", T: 5 /* ScalarType.INT32 */, opt: true },
    { no: 3, name: "filter", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListProjectsRequest {
    return new ListProjectsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListProjectsRequest {
    return new ListProjectsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListProjectsRequest {
    return new ListProjectsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListProjectsRequest | PlainMessage<ListProjectsRequest> | undefined, b: ListProjectsRequest | PlainMessage<ListProjectsRequest> | undefined): boolean {
    return proto3.util.equals(ListProjectsRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListProjectsResponse
 */
export class ListProjectsResponse extends Message<ListProjectsResponse> {
  /**
   * @generated from field: repeated github.com.akuity.kargo.api.v1alpha1.Project projects = 1;
   */
  projects: Project[] = [];

  /**
   * @generated from field: int32 total = 2;
   */
  total = 0;

  constructor(data?: PartialMessage<ListProjectsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListProjectsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "projects", kind: "message", T: Project, repeated: true },
    { no: 2, name: "total", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListProjectsResponse {
    return new ListProjectsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListProjectsResponse {
    return new ListProjectsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListProjectsResponse {
    return new ListProjectsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListProjectsResponse | PlainMessage<ListProjectsResponse> | undefined, b: ListProjectsResponse | PlainMessage<ListProjectsResponse> | undefined): boolean {
    return proto3.util.equals(ListProjectsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ApproveFreightRequest
 */
export class ApproveFreightRequest extends Message<ApproveFreightRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: string alias = 3;
   */
  alias = "";

  /**
   * @generated from field: string stage = 4;
   */
  stage = "";

  constructor(data?: PartialMessage<ApproveFreightRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ApproveFreightRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "alias", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "stage", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ApproveFreightRequest {
    return new ApproveFreightRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ApproveFreightRequest {
    return new ApproveFreightRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ApproveFreightRequest {
    return new ApproveFreightRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ApproveFreightRequest | PlainMessage<ApproveFreightRequest> | undefined, b: ApproveFreightRequest | PlainMessage<ApproveFreightRequest> | undefined): boolean {
    return proto3.util.equals(ApproveFreightRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.ApproveFreightResponse
 */
export class ApproveFreightResponse extends Message<ApproveFreightResponse> {
  constructor(data?: PartialMessage<ApproveFreightResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ApproveFreightResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ApproveFreightResponse {
    return new ApproveFreightResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ApproveFreightResponse {
    return new ApproveFreightResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ApproveFreightResponse {
    return new ApproveFreightResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ApproveFreightResponse | PlainMessage<ApproveFreightResponse> | undefined, b: ApproveFreightResponse | PlainMessage<ApproveFreightResponse> | undefined): boolean {
    return proto3.util.equals(ApproveFreightResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteFreightRequest
 */
export class DeleteFreightRequest extends Message<DeleteFreightRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: string alias = 3;
   */
  alias = "";

  constructor(data?: PartialMessage<DeleteFreightRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteFreightRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "alias", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteFreightRequest {
    return new DeleteFreightRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteFreightRequest {
    return new DeleteFreightRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteFreightRequest {
    return new DeleteFreightRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteFreightRequest | PlainMessage<DeleteFreightRequest> | undefined, b: DeleteFreightRequest | PlainMessage<DeleteFreightRequest> | undefined): boolean {
    return proto3.util.equals(DeleteFreightRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteFreightResponse
 */
export class DeleteFreightResponse extends Message<DeleteFreightResponse> {
  constructor(data?: PartialMessage<DeleteFreightResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteFreightResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteFreightResponse {
    return new DeleteFreightResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteFreightResponse {
    return new DeleteFreightResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteFreightResponse {
    return new DeleteFreightResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteFreightResponse | PlainMessage<DeleteFreightResponse> | undefined, b: DeleteFreightResponse | PlainMessage<DeleteFreightResponse> | undefined): boolean {
    return proto3.util.equals(DeleteFreightResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetFreightRequest
 */
export class GetFreightRequest extends Message<GetFreightRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: string alias = 3;
   */
  alias = "";

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 4;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetFreightRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetFreightRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "alias", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetFreightRequest {
    return new GetFreightRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetFreightRequest {
    return new GetFreightRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetFreightRequest {
    return new GetFreightRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetFreightRequest | PlainMessage<GetFreightRequest> | undefined, b: GetFreightRequest | PlainMessage<GetFreightRequest> | undefined): boolean {
    return proto3.util.equals(GetFreightRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetFreightResponse
 */
export class GetFreightResponse extends Message<GetFreightResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetFreightResponse.result
   */
  result: {
    /**
     * @generated from field: github.com.akuity.kargo.api.v1alpha1.Freight freight = 1;
     */
    value: Freight;
    case: "freight";
  } | {
    /**
     * @generated from field: bytes raw = 2;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetFreightResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetFreightResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "freight", kind: "message", T: Freight, oneof: "result" },
    { no: 2, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetFreightResponse {
    return new GetFreightResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetFreightResponse {
    return new GetFreightResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetFreightResponse {
    return new GetFreightResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetFreightResponse | PlainMessage<GetFreightResponse> | undefined, b: GetFreightResponse | PlainMessage<GetFreightResponse> | undefined): boolean {
    return proto3.util.equals(GetFreightResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.PromoteToStageRequest
 */
export class PromoteToStageRequest extends Message<PromoteToStageRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string stage = 2;
   */
  stage = "";

  /**
   * @generated from field: string freight = 3;
   */
  freight = "";

  /**
   * @generated from field: string freight_alias = 4;
   */
  freightAlias = "";

  constructor(data?: PartialMessage<PromoteToStageRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.PromoteToStageRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "stage", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "freight", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "freight_alias", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PromoteToStageRequest {
    return new PromoteToStageRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PromoteToStageRequest {
    return new PromoteToStageRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PromoteToStageRequest {
    return new PromoteToStageRequest().fromJsonString(jsonString, options);
  }

  static equals(a: PromoteToStageRequest | PlainMessage<PromoteToStageRequest> | undefined, b: PromoteToStageRequest | PlainMessage<PromoteToStageRequest> | undefined): boolean {
    return proto3.util.equals(PromoteToStageRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.PromoteToStageResponse
 */
export class PromoteToStageResponse extends Message<PromoteToStageResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.v1alpha1.Promotion promotion = 1;
   */
  promotion?: Promotion;

  constructor(data?: PartialMessage<PromoteToStageResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.PromoteToStageResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "promotion", kind: "message", T: Promotion },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PromoteToStageResponse {
    return new PromoteToStageResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PromoteToStageResponse {
    return new PromoteToStageResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PromoteToStageResponse {
    return new PromoteToStageResponse().fromJsonString(jsonString, options);
  }

  static equals(a: PromoteToStageResponse | PlainMessage<PromoteToStageResponse> | undefined, b: PromoteToStageResponse | PlainMessage<PromoteToStageResponse> | undefined): boolean {
    return proto3.util.equals(PromoteToStageResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.PromoteDownstreamRequest
 */
export class PromoteDownstreamRequest extends Message<PromoteDownstreamRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string stage = 2;
   */
  stage = "";

  /**
   * @generated from field: string freight = 3;
   */
  freight = "";

  /**
   * @generated from field: string freight_alias = 4;
   */
  freightAlias = "";

  constructor(data?: PartialMessage<PromoteDownstreamRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.PromoteDownstreamRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "stage", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "freight", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "freight_alias", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PromoteDownstreamRequest {
    return new PromoteDownstreamRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PromoteDownstreamRequest {
    return new PromoteDownstreamRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PromoteDownstreamRequest {
    return new PromoteDownstreamRequest().fromJsonString(jsonString, options);
  }

  static equals(a: PromoteDownstreamRequest | PlainMessage<PromoteDownstreamRequest> | undefined, b: PromoteDownstreamRequest | PlainMessage<PromoteDownstreamRequest> | undefined): boolean {
    return proto3.util.equals(PromoteDownstreamRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.PromoteDownstreamResponse
 */
export class PromoteDownstreamResponse extends Message<PromoteDownstreamResponse> {
  /**
   * @generated from field: repeated github.com.akuity.kargo.api.v1alpha1.Promotion promotions = 1;
   */
  promotions: Promotion[] = [];

  constructor(data?: PartialMessage<PromoteDownstreamResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.PromoteDownstreamResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "promotions", kind: "message", T: Promotion, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): PromoteDownstreamResponse {
    return new PromoteDownstreamResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): PromoteDownstreamResponse {
    return new PromoteDownstreamResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): PromoteDownstreamResponse {
    return new PromoteDownstreamResponse().fromJsonString(jsonString, options);
  }

  static equals(a: PromoteDownstreamResponse | PlainMessage<PromoteDownstreamResponse> | undefined, b: PromoteDownstreamResponse | PlainMessage<PromoteDownstreamResponse> | undefined): boolean {
    return proto3.util.equals(PromoteDownstreamResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.QueryFreightRequest
 */
export class QueryFreightRequest extends Message<QueryFreightRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string stage = 2;
   */
  stage = "";

  /**
   * @generated from field: string group_by = 3;
   */
  groupBy = "";

  /**
   * @generated from field: string group = 4;
   */
  group = "";

  /**
   * @generated from field: string order_by = 5;
   */
  orderBy = "";

  /**
   * @generated from field: bool reverse = 6;
   */
  reverse = false;

  /**
   * @generated from field: repeated string origins = 7;
   */
  origins: string[] = [];

  constructor(data?: PartialMessage<QueryFreightRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.QueryFreightRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "stage", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "group_by", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "group", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "order_by", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "reverse", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 7, name: "origins", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryFreightRequest {
    return new QueryFreightRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryFreightRequest {
    return new QueryFreightRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryFreightRequest {
    return new QueryFreightRequest().fromJsonString(jsonString, options);
  }

  static equals(a: QueryFreightRequest | PlainMessage<QueryFreightRequest> | undefined, b: QueryFreightRequest | PlainMessage<QueryFreightRequest> | undefined): boolean {
    return proto3.util.equals(QueryFreightRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.QueryFreightResponse
 */
export class QueryFreightResponse extends Message<QueryFreightResponse> {
  /**
   * @generated from field: map<string, akuity.io.kargo.service.v1alpha1.FreightList> groups = 1;
   */
  groups: { [key: string]: FreightList } = {};

  constructor(data?: PartialMessage<QueryFreightResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.QueryFreightResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "groups", kind: "map", K: 9 /* ScalarType.STRING */, V: {kind: "message", T: FreightList} },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): QueryFreightResponse {
    return new QueryFreightResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): QueryFreightResponse {
    return new QueryFreightResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): QueryFreightResponse {
    return new QueryFreightResponse().fromJsonString(jsonString, options);
  }

  static equals(a: QueryFreightResponse | PlainMessage<QueryFreightResponse> | undefined, b: QueryFreightResponse | PlainMessage<QueryFreightResponse> | undefined): boolean {
    return proto3.util.equals(QueryFreightResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.FreightList
 */
export class FreightList extends Message<FreightList> {
  /**
   * @generated from field: repeated github.com.akuity.kargo.api.v1alpha1.Freight freight = 1;
   */
  freight: Freight[] = [];

  constructor(data?: PartialMessage<FreightList>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.FreightList";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "freight", kind: "message", T: Freight, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): FreightList {
    return new FreightList().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): FreightList {
    return new FreightList().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): FreightList {
    return new FreightList().fromJsonString(jsonString, options);
  }

  static equals(a: FreightList | PlainMessage<FreightList> | undefined, b: FreightList | PlainMessage<FreightList> | undefined): boolean {
    return proto3.util.equals(FreightList, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.UpdateFreightAliasRequest
 */
export class UpdateFreightAliasRequest extends Message<UpdateFreightAliasRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: string old_alias = 3;
   */
  oldAlias = "";

  /**
   * @generated from field: string new_alias = 4;
   */
  newAlias = "";

  constructor(data?: PartialMessage<UpdateFreightAliasRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.UpdateFreightAliasRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "old_alias", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "new_alias", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateFreightAliasRequest {
    return new UpdateFreightAliasRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateFreightAliasRequest {
    return new UpdateFreightAliasRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateFreightAliasRequest {
    return new UpdateFreightAliasRequest().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateFreightAliasRequest | PlainMessage<UpdateFreightAliasRequest> | undefined, b: UpdateFreightAliasRequest | PlainMessage<UpdateFreightAliasRequest> | undefined): boolean {
    return proto3.util.equals(UpdateFreightAliasRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.UpdateFreightAliasResponse
 */
export class UpdateFreightAliasResponse extends Message<UpdateFreightAliasResponse> {
  constructor(data?: PartialMessage<UpdateFreightAliasResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.UpdateFreightAliasResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateFreightAliasResponse {
    return new UpdateFreightAliasResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateFreightAliasResponse {
    return new UpdateFreightAliasResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateFreightAliasResponse {
    return new UpdateFreightAliasResponse().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateFreightAliasResponse | PlainMessage<UpdateFreightAliasResponse> | undefined, b: UpdateFreightAliasResponse | PlainMessage<UpdateFreightAliasResponse> | undefined): boolean {
    return proto3.util.equals(UpdateFreightAliasResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ReverifyRequest
 */
export class ReverifyRequest extends Message<ReverifyRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string stage = 2;
   */
  stage = "";

  constructor(data?: PartialMessage<ReverifyRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ReverifyRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "stage", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ReverifyRequest {
    return new ReverifyRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ReverifyRequest {
    return new ReverifyRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ReverifyRequest {
    return new ReverifyRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ReverifyRequest | PlainMessage<ReverifyRequest> | undefined, b: ReverifyRequest | PlainMessage<ReverifyRequest> | undefined): boolean {
    return proto3.util.equals(ReverifyRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.ReverifyResponse
 */
export class ReverifyResponse extends Message<ReverifyResponse> {
  constructor(data?: PartialMessage<ReverifyResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ReverifyResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ReverifyResponse {
    return new ReverifyResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ReverifyResponse {
    return new ReverifyResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ReverifyResponse {
    return new ReverifyResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ReverifyResponse | PlainMessage<ReverifyResponse> | undefined, b: ReverifyResponse | PlainMessage<ReverifyResponse> | undefined): boolean {
    return proto3.util.equals(ReverifyResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.AbortVerificationRequest
 */
export class AbortVerificationRequest extends Message<AbortVerificationRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string stage = 2;
   */
  stage = "";

  constructor(data?: PartialMessage<AbortVerificationRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.AbortVerificationRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "stage", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AbortVerificationRequest {
    return new AbortVerificationRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AbortVerificationRequest {
    return new AbortVerificationRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AbortVerificationRequest {
    return new AbortVerificationRequest().fromJsonString(jsonString, options);
  }

  static equals(a: AbortVerificationRequest | PlainMessage<AbortVerificationRequest> | undefined, b: AbortVerificationRequest | PlainMessage<AbortVerificationRequest> | undefined): boolean {
    return proto3.util.equals(AbortVerificationRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.AbortVerificationResponse
 */
export class AbortVerificationResponse extends Message<AbortVerificationResponse> {
  constructor(data?: PartialMessage<AbortVerificationResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.AbortVerificationResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): AbortVerificationResponse {
    return new AbortVerificationResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): AbortVerificationResponse {
    return new AbortVerificationResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): AbortVerificationResponse {
    return new AbortVerificationResponse().fromJsonString(jsonString, options);
  }

  static equals(a: AbortVerificationResponse | PlainMessage<AbortVerificationResponse> | undefined, b: AbortVerificationResponse | PlainMessage<AbortVerificationResponse> | undefined): boolean {
    return proto3.util.equals(AbortVerificationResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListWarehousesRequest
 */
export class ListWarehousesRequest extends Message<ListWarehousesRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  constructor(data?: PartialMessage<ListWarehousesRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListWarehousesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListWarehousesRequest {
    return new ListWarehousesRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListWarehousesRequest {
    return new ListWarehousesRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListWarehousesRequest {
    return new ListWarehousesRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListWarehousesRequest | PlainMessage<ListWarehousesRequest> | undefined, b: ListWarehousesRequest | PlainMessage<ListWarehousesRequest> | undefined): boolean {
    return proto3.util.equals(ListWarehousesRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListWarehousesResponse
 */
export class ListWarehousesResponse extends Message<ListWarehousesResponse> {
  /**
   * @generated from field: repeated github.com.akuity.kargo.api.v1alpha1.Warehouse warehouses = 1;
   */
  warehouses: Warehouse[] = [];

  constructor(data?: PartialMessage<ListWarehousesResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListWarehousesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "warehouses", kind: "message", T: Warehouse, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListWarehousesResponse {
    return new ListWarehousesResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListWarehousesResponse {
    return new ListWarehousesResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListWarehousesResponse {
    return new ListWarehousesResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListWarehousesResponse | PlainMessage<ListWarehousesResponse> | undefined, b: ListWarehousesResponse | PlainMessage<ListWarehousesResponse> | undefined): boolean {
    return proto3.util.equals(ListWarehousesResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetWarehouseRequest
 */
export class GetWarehouseRequest extends Message<GetWarehouseRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 3;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetWarehouseRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetWarehouseRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetWarehouseRequest {
    return new GetWarehouseRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetWarehouseRequest {
    return new GetWarehouseRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetWarehouseRequest {
    return new GetWarehouseRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetWarehouseRequest | PlainMessage<GetWarehouseRequest> | undefined, b: GetWarehouseRequest | PlainMessage<GetWarehouseRequest> | undefined): boolean {
    return proto3.util.equals(GetWarehouseRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetWarehouseResponse
 */
export class GetWarehouseResponse extends Message<GetWarehouseResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetWarehouseResponse.result
   */
  result: {
    /**
     * @generated from field: github.com.akuity.kargo.api.v1alpha1.Warehouse warehouse = 1;
     */
    value: Warehouse;
    case: "warehouse";
  } | {
    /**
     * @generated from field: bytes raw = 2;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetWarehouseResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetWarehouseResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "warehouse", kind: "message", T: Warehouse, oneof: "result" },
    { no: 2, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetWarehouseResponse {
    return new GetWarehouseResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetWarehouseResponse {
    return new GetWarehouseResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetWarehouseResponse {
    return new GetWarehouseResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetWarehouseResponse | PlainMessage<GetWarehouseResponse> | undefined, b: GetWarehouseResponse | PlainMessage<GetWarehouseResponse> | undefined): boolean {
    return proto3.util.equals(GetWarehouseResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.WatchWarehousesRequest
 */
export class WatchWarehousesRequest extends Message<WatchWarehousesRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<WatchWarehousesRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.WatchWarehousesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WatchWarehousesRequest {
    return new WatchWarehousesRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WatchWarehousesRequest {
    return new WatchWarehousesRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WatchWarehousesRequest {
    return new WatchWarehousesRequest().fromJsonString(jsonString, options);
  }

  static equals(a: WatchWarehousesRequest | PlainMessage<WatchWarehousesRequest> | undefined, b: WatchWarehousesRequest | PlainMessage<WatchWarehousesRequest> | undefined): boolean {
    return proto3.util.equals(WatchWarehousesRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.WatchWarehousesResponse
 */
export class WatchWarehousesResponse extends Message<WatchWarehousesResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.v1alpha1.Warehouse warehouse = 1;
   */
  warehouse?: Warehouse;

  /**
   * @generated from field: string type = 2;
   */
  type = "";

  constructor(data?: PartialMessage<WatchWarehousesResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.WatchWarehousesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "warehouse", kind: "message", T: Warehouse },
    { no: 2, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WatchWarehousesResponse {
    return new WatchWarehousesResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WatchWarehousesResponse {
    return new WatchWarehousesResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WatchWarehousesResponse {
    return new WatchWarehousesResponse().fromJsonString(jsonString, options);
  }

  static equals(a: WatchWarehousesResponse | PlainMessage<WatchWarehousesResponse> | undefined, b: WatchWarehousesResponse | PlainMessage<WatchWarehousesResponse> | undefined): boolean {
    return proto3.util.equals(WatchWarehousesResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteWarehouseRequest
 */
export class DeleteWarehouseRequest extends Message<DeleteWarehouseRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<DeleteWarehouseRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteWarehouseRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteWarehouseRequest {
    return new DeleteWarehouseRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteWarehouseRequest {
    return new DeleteWarehouseRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteWarehouseRequest {
    return new DeleteWarehouseRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteWarehouseRequest | PlainMessage<DeleteWarehouseRequest> | undefined, b: DeleteWarehouseRequest | PlainMessage<DeleteWarehouseRequest> | undefined): boolean {
    return proto3.util.equals(DeleteWarehouseRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteWarehouseResponse
 */
export class DeleteWarehouseResponse extends Message<DeleteWarehouseResponse> {
  constructor(data?: PartialMessage<DeleteWarehouseResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteWarehouseResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteWarehouseResponse {
    return new DeleteWarehouseResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteWarehouseResponse {
    return new DeleteWarehouseResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteWarehouseResponse {
    return new DeleteWarehouseResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteWarehouseResponse | PlainMessage<DeleteWarehouseResponse> | undefined, b: DeleteWarehouseResponse | PlainMessage<DeleteWarehouseResponse> | undefined): boolean {
    return proto3.util.equals(DeleteWarehouseResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.RefreshWarehouseRequest
 */
export class RefreshWarehouseRequest extends Message<RefreshWarehouseRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<RefreshWarehouseRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.RefreshWarehouseRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RefreshWarehouseRequest {
    return new RefreshWarehouseRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RefreshWarehouseRequest {
    return new RefreshWarehouseRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RefreshWarehouseRequest {
    return new RefreshWarehouseRequest().fromJsonString(jsonString, options);
  }

  static equals(a: RefreshWarehouseRequest | PlainMessage<RefreshWarehouseRequest> | undefined, b: RefreshWarehouseRequest | PlainMessage<RefreshWarehouseRequest> | undefined): boolean {
    return proto3.util.equals(RefreshWarehouseRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.RefreshWarehouseResponse
 */
export class RefreshWarehouseResponse extends Message<RefreshWarehouseResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.v1alpha1.Warehouse warehouse = 1;
   */
  warehouse?: Warehouse;

  constructor(data?: PartialMessage<RefreshWarehouseResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.RefreshWarehouseResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "warehouse", kind: "message", T: Warehouse },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RefreshWarehouseResponse {
    return new RefreshWarehouseResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RefreshWarehouseResponse {
    return new RefreshWarehouseResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RefreshWarehouseResponse {
    return new RefreshWarehouseResponse().fromJsonString(jsonString, options);
  }

  static equals(a: RefreshWarehouseResponse | PlainMessage<RefreshWarehouseResponse> | undefined, b: RefreshWarehouseResponse | PlainMessage<RefreshWarehouseResponse> | undefined): boolean {
    return proto3.util.equals(RefreshWarehouseResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.CreateCredentialsRequest
 */
export class CreateCredentialsRequest extends Message<CreateCredentialsRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: string description = 8;
   */
  description = "";

  /**
   * @generated from field: string type = 3;
   */
  type = "";

  /**
   * @generated from field: string repo_url = 4 [json_name = "repoURL"];
   */
  repoUrl = "";

  /**
   * @generated from field: bool repo_url_is_regex = 5 [json_name = "repoURLIsRegex"];
   */
  repoUrlIsRegex = false;

  /**
   * @generated from field: string username = 6;
   */
  username = "";

  /**
   * @generated from field: string password = 7;
   */
  password = "";

  constructor(data?: PartialMessage<CreateCredentialsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.CreateCredentialsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "repo_url", jsonName: "repoURL", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "repo_url_is_regex", jsonName: "repoURLIsRegex", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 6, name: "username", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "password", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateCredentialsRequest {
    return new CreateCredentialsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateCredentialsRequest {
    return new CreateCredentialsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateCredentialsRequest {
    return new CreateCredentialsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: CreateCredentialsRequest | PlainMessage<CreateCredentialsRequest> | undefined, b: CreateCredentialsRequest | PlainMessage<CreateCredentialsRequest> | undefined): boolean {
    return proto3.util.equals(CreateCredentialsRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.CreateCredentialsResponse
 */
export class CreateCredentialsResponse extends Message<CreateCredentialsResponse> {
  /**
   * @generated from field: k8s.io.api.core.v1.Secret credentials = 1;
   */
  credentials?: Secret;

  constructor(data?: PartialMessage<CreateCredentialsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.CreateCredentialsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "credentials", kind: "message", T: Secret },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateCredentialsResponse {
    return new CreateCredentialsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateCredentialsResponse {
    return new CreateCredentialsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateCredentialsResponse {
    return new CreateCredentialsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: CreateCredentialsResponse | PlainMessage<CreateCredentialsResponse> | undefined, b: CreateCredentialsResponse | PlainMessage<CreateCredentialsResponse> | undefined): boolean {
    return proto3.util.equals(CreateCredentialsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteCredentialsRequest
 */
export class DeleteCredentialsRequest extends Message<DeleteCredentialsRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<DeleteCredentialsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteCredentialsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteCredentialsRequest {
    return new DeleteCredentialsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteCredentialsRequest {
    return new DeleteCredentialsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteCredentialsRequest {
    return new DeleteCredentialsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteCredentialsRequest | PlainMessage<DeleteCredentialsRequest> | undefined, b: DeleteCredentialsRequest | PlainMessage<DeleteCredentialsRequest> | undefined): boolean {
    return proto3.util.equals(DeleteCredentialsRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteCredentialsResponse
 */
export class DeleteCredentialsResponse extends Message<DeleteCredentialsResponse> {
  constructor(data?: PartialMessage<DeleteCredentialsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteCredentialsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteCredentialsResponse {
    return new DeleteCredentialsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteCredentialsResponse {
    return new DeleteCredentialsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteCredentialsResponse {
    return new DeleteCredentialsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteCredentialsResponse | PlainMessage<DeleteCredentialsResponse> | undefined, b: DeleteCredentialsResponse | PlainMessage<DeleteCredentialsResponse> | undefined): boolean {
    return proto3.util.equals(DeleteCredentialsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetCredentialsRequest
 */
export class GetCredentialsRequest extends Message<GetCredentialsRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 3;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetCredentialsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetCredentialsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetCredentialsRequest {
    return new GetCredentialsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetCredentialsRequest {
    return new GetCredentialsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetCredentialsRequest {
    return new GetCredentialsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetCredentialsRequest | PlainMessage<GetCredentialsRequest> | undefined, b: GetCredentialsRequest | PlainMessage<GetCredentialsRequest> | undefined): boolean {
    return proto3.util.equals(GetCredentialsRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetCredentialsResponse
 */
export class GetCredentialsResponse extends Message<GetCredentialsResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetCredentialsResponse.result
   */
  result: {
    /**
     * @generated from field: k8s.io.api.core.v1.Secret credentials = 1;
     */
    value: Secret;
    case: "credentials";
  } | {
    /**
     * @generated from field: bytes raw = 2;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetCredentialsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetCredentialsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "credentials", kind: "message", T: Secret, oneof: "result" },
    { no: 2, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetCredentialsResponse {
    return new GetCredentialsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetCredentialsResponse {
    return new GetCredentialsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetCredentialsResponse {
    return new GetCredentialsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetCredentialsResponse | PlainMessage<GetCredentialsResponse> | undefined, b: GetCredentialsResponse | PlainMessage<GetCredentialsResponse> | undefined): boolean {
    return proto3.util.equals(GetCredentialsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListCredentialsRequest
 */
export class ListCredentialsRequest extends Message<ListCredentialsRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  constructor(data?: PartialMessage<ListCredentialsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListCredentialsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListCredentialsRequest {
    return new ListCredentialsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListCredentialsRequest {
    return new ListCredentialsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListCredentialsRequest {
    return new ListCredentialsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListCredentialsRequest | PlainMessage<ListCredentialsRequest> | undefined, b: ListCredentialsRequest | PlainMessage<ListCredentialsRequest> | undefined): boolean {
    return proto3.util.equals(ListCredentialsRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListCredentialsResponse
 */
export class ListCredentialsResponse extends Message<ListCredentialsResponse> {
  /**
   * @generated from field: repeated k8s.io.api.core.v1.Secret credentials = 1;
   */
  credentials: Secret[] = [];

  constructor(data?: PartialMessage<ListCredentialsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListCredentialsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "credentials", kind: "message", T: Secret, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListCredentialsResponse {
    return new ListCredentialsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListCredentialsResponse {
    return new ListCredentialsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListCredentialsResponse {
    return new ListCredentialsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListCredentialsResponse | PlainMessage<ListCredentialsResponse> | undefined, b: ListCredentialsResponse | PlainMessage<ListCredentialsResponse> | undefined): boolean {
    return proto3.util.equals(ListCredentialsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.UpdateCredentialsRequest
 */
export class UpdateCredentialsRequest extends Message<UpdateCredentialsRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: string description = 8;
   */
  description = "";

  /**
   * @generated from field: string type = 3;
   */
  type = "";

  /**
   * @generated from field: string repo_url = 4 [json_name = "repoURL"];
   */
  repoUrl = "";

  /**
   * @generated from field: bool repo_url_is_regex = 5 [json_name = "repoURLIsRegex"];
   */
  repoUrlIsRegex = false;

  /**
   * @generated from field: string username = 6;
   */
  username = "";

  /**
   * @generated from field: string password = 7;
   */
  password = "";

  constructor(data?: PartialMessage<UpdateCredentialsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.UpdateCredentialsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "repo_url", jsonName: "repoURL", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "repo_url_is_regex", jsonName: "repoURLIsRegex", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 6, name: "username", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "password", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateCredentialsRequest {
    return new UpdateCredentialsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateCredentialsRequest {
    return new UpdateCredentialsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateCredentialsRequest {
    return new UpdateCredentialsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateCredentialsRequest | PlainMessage<UpdateCredentialsRequest> | undefined, b: UpdateCredentialsRequest | PlainMessage<UpdateCredentialsRequest> | undefined): boolean {
    return proto3.util.equals(UpdateCredentialsRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.UpdateCredentialsResponse
 */
export class UpdateCredentialsResponse extends Message<UpdateCredentialsResponse> {
  /**
   * @generated from field: k8s.io.api.core.v1.Secret credentials = 1;
   */
  credentials?: Secret;

  constructor(data?: PartialMessage<UpdateCredentialsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.UpdateCredentialsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "credentials", kind: "message", T: Secret },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateCredentialsResponse {
    return new UpdateCredentialsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateCredentialsResponse {
    return new UpdateCredentialsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateCredentialsResponse {
    return new UpdateCredentialsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateCredentialsResponse | PlainMessage<UpdateCredentialsResponse> | undefined, b: UpdateCredentialsResponse | PlainMessage<UpdateCredentialsResponse> | undefined): boolean {
    return proto3.util.equals(UpdateCredentialsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListAnalysisTemplatesRequest
 */
export class ListAnalysisTemplatesRequest extends Message<ListAnalysisTemplatesRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  constructor(data?: PartialMessage<ListAnalysisTemplatesRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListAnalysisTemplatesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListAnalysisTemplatesRequest {
    return new ListAnalysisTemplatesRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListAnalysisTemplatesRequest {
    return new ListAnalysisTemplatesRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListAnalysisTemplatesRequest {
    return new ListAnalysisTemplatesRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListAnalysisTemplatesRequest | PlainMessage<ListAnalysisTemplatesRequest> | undefined, b: ListAnalysisTemplatesRequest | PlainMessage<ListAnalysisTemplatesRequest> | undefined): boolean {
    return proto3.util.equals(ListAnalysisTemplatesRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListAnalysisTemplatesResponse
 */
export class ListAnalysisTemplatesResponse extends Message<ListAnalysisTemplatesResponse> {
  /**
   * @generated from field: repeated github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.AnalysisTemplate analysis_templates = 1;
   */
  analysisTemplates: AnalysisTemplate[] = [];

  constructor(data?: PartialMessage<ListAnalysisTemplatesResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListAnalysisTemplatesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "analysis_templates", kind: "message", T: AnalysisTemplate, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListAnalysisTemplatesResponse {
    return new ListAnalysisTemplatesResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListAnalysisTemplatesResponse {
    return new ListAnalysisTemplatesResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListAnalysisTemplatesResponse {
    return new ListAnalysisTemplatesResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListAnalysisTemplatesResponse | PlainMessage<ListAnalysisTemplatesResponse> | undefined, b: ListAnalysisTemplatesResponse | PlainMessage<ListAnalysisTemplatesResponse> | undefined): boolean {
    return proto3.util.equals(ListAnalysisTemplatesResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateRequest
 */
export class GetAnalysisTemplateRequest extends Message<GetAnalysisTemplateRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 3;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetAnalysisTemplateRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAnalysisTemplateRequest {
    return new GetAnalysisTemplateRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAnalysisTemplateRequest {
    return new GetAnalysisTemplateRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAnalysisTemplateRequest {
    return new GetAnalysisTemplateRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetAnalysisTemplateRequest | PlainMessage<GetAnalysisTemplateRequest> | undefined, b: GetAnalysisTemplateRequest | PlainMessage<GetAnalysisTemplateRequest> | undefined): boolean {
    return proto3.util.equals(GetAnalysisTemplateRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateResponse
 */
export class GetAnalysisTemplateResponse extends Message<GetAnalysisTemplateResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateResponse.result
   */
  result: {
    /**
     * @generated from field: github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.AnalysisTemplate analysis_template = 1;
     */
    value: AnalysisTemplate;
    case: "analysisTemplate";
  } | {
    /**
     * @generated from field: bytes raw = 2;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetAnalysisTemplateResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "analysis_template", kind: "message", T: AnalysisTemplate, oneof: "result" },
    { no: 2, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAnalysisTemplateResponse {
    return new GetAnalysisTemplateResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAnalysisTemplateResponse {
    return new GetAnalysisTemplateResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAnalysisTemplateResponse {
    return new GetAnalysisTemplateResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetAnalysisTemplateResponse | PlainMessage<GetAnalysisTemplateResponse> | undefined, b: GetAnalysisTemplateResponse | PlainMessage<GetAnalysisTemplateResponse> | undefined): boolean {
    return proto3.util.equals(GetAnalysisTemplateResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetAnalysisRunRequest
 */
export class GetAnalysisRunRequest extends Message<GetAnalysisRunRequest> {
  /**
   * @generated from field: string namespace = 1;
   */
  namespace = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 3;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetAnalysisRunRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetAnalysisRunRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "namespace", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAnalysisRunRequest {
    return new GetAnalysisRunRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAnalysisRunRequest {
    return new GetAnalysisRunRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAnalysisRunRequest {
    return new GetAnalysisRunRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetAnalysisRunRequest | PlainMessage<GetAnalysisRunRequest> | undefined, b: GetAnalysisRunRequest | PlainMessage<GetAnalysisRunRequest> | undefined): boolean {
    return proto3.util.equals(GetAnalysisRunRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetAnalysisRunResponse
 */
export class GetAnalysisRunResponse extends Message<GetAnalysisRunResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetAnalysisRunResponse.result
   */
  result: {
    /**
     * @generated from field: github.com.akuity.kargo.internal.controller.rollouts.api.v1alpha1.AnalysisRun analysis_run = 1;
     */
    value: AnalysisRun;
    case: "analysisRun";
  } | {
    /**
     * @generated from field: bytes raw = 2;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetAnalysisRunResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetAnalysisRunResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "analysis_run", kind: "message", T: AnalysisRun, oneof: "result" },
    { no: 2, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAnalysisRunResponse {
    return new GetAnalysisRunResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAnalysisRunResponse {
    return new GetAnalysisRunResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAnalysisRunResponse {
    return new GetAnalysisRunResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetAnalysisRunResponse | PlainMessage<GetAnalysisRunResponse> | undefined, b: GetAnalysisRunResponse | PlainMessage<GetAnalysisRunResponse> | undefined): boolean {
    return proto3.util.equals(GetAnalysisRunResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteAnalysisTemplateRequest
 */
export class DeleteAnalysisTemplateRequest extends Message<DeleteAnalysisTemplateRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<DeleteAnalysisTemplateRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteAnalysisTemplateRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteAnalysisTemplateRequest {
    return new DeleteAnalysisTemplateRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteAnalysisTemplateRequest {
    return new DeleteAnalysisTemplateRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteAnalysisTemplateRequest {
    return new DeleteAnalysisTemplateRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteAnalysisTemplateRequest | PlainMessage<DeleteAnalysisTemplateRequest> | undefined, b: DeleteAnalysisTemplateRequest | PlainMessage<DeleteAnalysisTemplateRequest> | undefined): boolean {
    return proto3.util.equals(DeleteAnalysisTemplateRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteAnalysisTemplateResponse
 */
export class DeleteAnalysisTemplateResponse extends Message<DeleteAnalysisTemplateResponse> {
  constructor(data?: PartialMessage<DeleteAnalysisTemplateResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteAnalysisTemplateResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteAnalysisTemplateResponse {
    return new DeleteAnalysisTemplateResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteAnalysisTemplateResponse {
    return new DeleteAnalysisTemplateResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteAnalysisTemplateResponse {
    return new DeleteAnalysisTemplateResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteAnalysisTemplateResponse | PlainMessage<DeleteAnalysisTemplateResponse> | undefined, b: DeleteAnalysisTemplateResponse | PlainMessage<DeleteAnalysisTemplateResponse> | undefined): boolean {
    return proto3.util.equals(DeleteAnalysisTemplateResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListProjectEventsRequest
 */
export class ListProjectEventsRequest extends Message<ListProjectEventsRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  constructor(data?: PartialMessage<ListProjectEventsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListProjectEventsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListProjectEventsRequest {
    return new ListProjectEventsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListProjectEventsRequest {
    return new ListProjectEventsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListProjectEventsRequest {
    return new ListProjectEventsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListProjectEventsRequest | PlainMessage<ListProjectEventsRequest> | undefined, b: ListProjectEventsRequest | PlainMessage<ListProjectEventsRequest> | undefined): boolean {
    return proto3.util.equals(ListProjectEventsRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListProjectEventsResponse
 */
export class ListProjectEventsResponse extends Message<ListProjectEventsResponse> {
  /**
   * @generated from field: repeated k8s.io.api.core.v1.Event events = 1;
   */
  events: Event[] = [];

  constructor(data?: PartialMessage<ListProjectEventsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListProjectEventsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "events", kind: "message", T: Event, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListProjectEventsResponse {
    return new ListProjectEventsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListProjectEventsResponse {
    return new ListProjectEventsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListProjectEventsResponse {
    return new ListProjectEventsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListProjectEventsResponse | PlainMessage<ListProjectEventsResponse> | undefined, b: ListProjectEventsResponse | PlainMessage<ListProjectEventsResponse> | undefined): boolean {
    return proto3.util.equals(ListProjectEventsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.CreateRoleRequest
 */
export class CreateRoleRequest extends Message<CreateRoleRequest> {
  /**
   * @generated from field: github.com.akuity.kargo.api.rbac.v1alpha1.Role role = 1;
   */
  role?: Role;

  constructor(data?: PartialMessage<CreateRoleRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.CreateRoleRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "role", kind: "message", T: Role },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateRoleRequest {
    return new CreateRoleRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateRoleRequest {
    return new CreateRoleRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateRoleRequest {
    return new CreateRoleRequest().fromJsonString(jsonString, options);
  }

  static equals(a: CreateRoleRequest | PlainMessage<CreateRoleRequest> | undefined, b: CreateRoleRequest | PlainMessage<CreateRoleRequest> | undefined): boolean {
    return proto3.util.equals(CreateRoleRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.CreateRoleResponse
 */
export class CreateRoleResponse extends Message<CreateRoleResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.rbac.v1alpha1.Role role = 1;
   */
  role?: Role;

  constructor(data?: PartialMessage<CreateRoleResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.CreateRoleResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "role", kind: "message", T: Role },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateRoleResponse {
    return new CreateRoleResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateRoleResponse {
    return new CreateRoleResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateRoleResponse {
    return new CreateRoleResponse().fromJsonString(jsonString, options);
  }

  static equals(a: CreateRoleResponse | PlainMessage<CreateRoleResponse> | undefined, b: CreateRoleResponse | PlainMessage<CreateRoleResponse> | undefined): boolean {
    return proto3.util.equals(CreateRoleResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteRoleRequest
 */
export class DeleteRoleRequest extends Message<DeleteRoleRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  constructor(data?: PartialMessage<DeleteRoleRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteRoleRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteRoleRequest {
    return new DeleteRoleRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteRoleRequest {
    return new DeleteRoleRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteRoleRequest {
    return new DeleteRoleRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteRoleRequest | PlainMessage<DeleteRoleRequest> | undefined, b: DeleteRoleRequest | PlainMessage<DeleteRoleRequest> | undefined): boolean {
    return proto3.util.equals(DeleteRoleRequest, a, b);
  }
}

/**
 * explicitly empty 
 *
 * @generated from message akuity.io.kargo.service.v1alpha1.DeleteRoleResponse
 */
export class DeleteRoleResponse extends Message<DeleteRoleResponse> {
  constructor(data?: PartialMessage<DeleteRoleResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.DeleteRoleResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteRoleResponse {
    return new DeleteRoleResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteRoleResponse {
    return new DeleteRoleResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteRoleResponse {
    return new DeleteRoleResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteRoleResponse | PlainMessage<DeleteRoleResponse> | undefined, b: DeleteRoleResponse | PlainMessage<DeleteRoleResponse> | undefined): boolean {
    return proto3.util.equals(DeleteRoleResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetRoleRequest
 */
export class GetRoleRequest extends Message<GetRoleRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: bool as_resources = 3;
   */
  asResources = false;

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 4;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetRoleRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetRoleRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "as_resources", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 4, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetRoleRequest {
    return new GetRoleRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetRoleRequest {
    return new GetRoleRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetRoleRequest {
    return new GetRoleRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetRoleRequest | PlainMessage<GetRoleRequest> | undefined, b: GetRoleRequest | PlainMessage<GetRoleRequest> | undefined): boolean {
    return proto3.util.equals(GetRoleRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetRoleResponse
 */
export class GetRoleResponse extends Message<GetRoleResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetRoleResponse.result
   */
  result: {
    /**
     * @generated from field: github.com.akuity.kargo.api.rbac.v1alpha1.Role role = 1;
     */
    value: Role;
    case: "role";
  } | {
    /**
     * @generated from field: github.com.akuity.kargo.api.rbac.v1alpha1.RoleResources resources = 2;
     */
    value: RoleResources;
    case: "resources";
  } | {
    /**
     * @generated from field: bytes raw = 3;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetRoleResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetRoleResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "role", kind: "message", T: Role, oneof: "result" },
    { no: 2, name: "resources", kind: "message", T: RoleResources, oneof: "result" },
    { no: 3, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetRoleResponse {
    return new GetRoleResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetRoleResponse {
    return new GetRoleResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetRoleResponse {
    return new GetRoleResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetRoleResponse | PlainMessage<GetRoleResponse> | undefined, b: GetRoleResponse | PlainMessage<GetRoleResponse> | undefined): boolean {
    return proto3.util.equals(GetRoleResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.Claims
 */
export class Claims extends Message<Claims> {
  /**
   * Note: oneof and repeated do not work together
   *
   * @generated from field: repeated github.com.akuity.kargo.api.rbac.v1alpha1.Claim claims = 1;
   */
  claims: Claim[] = [];

  constructor(data?: PartialMessage<Claims>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.Claims";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "claims", kind: "message", T: Claim, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Claims {
    return new Claims().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Claims {
    return new Claims().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Claims {
    return new Claims().fromJsonString(jsonString, options);
  }

  static equals(a: Claims | PlainMessage<Claims> | undefined, b: Claims | PlainMessage<Claims> | undefined): boolean {
    return proto3.util.equals(Claims, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GrantRequest
 */
export class GrantRequest extends Message<GrantRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string role = 2;
   */
  role = "";

  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GrantRequest.request
   */
  request: {
    /**
     * @generated from field: akuity.io.kargo.service.v1alpha1.Claims user_claims = 3;
     */
    value: Claims;
    case: "userClaims";
  } | {
    /**
     * @generated from field: github.com.akuity.kargo.api.rbac.v1alpha1.ResourceDetails resource_details = 4;
     */
    value: ResourceDetails;
    case: "resourceDetails";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GrantRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GrantRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "role", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "user_claims", kind: "message", T: Claims, oneof: "request" },
    { no: 4, name: "resource_details", kind: "message", T: ResourceDetails, oneof: "request" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GrantRequest {
    return new GrantRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GrantRequest {
    return new GrantRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GrantRequest {
    return new GrantRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GrantRequest | PlainMessage<GrantRequest> | undefined, b: GrantRequest | PlainMessage<GrantRequest> | undefined): boolean {
    return proto3.util.equals(GrantRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GrantResponse
 */
export class GrantResponse extends Message<GrantResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.rbac.v1alpha1.Role role = 1;
   */
  role?: Role;

  constructor(data?: PartialMessage<GrantResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GrantResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "role", kind: "message", T: Role },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GrantResponse {
    return new GrantResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GrantResponse {
    return new GrantResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GrantResponse {
    return new GrantResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GrantResponse | PlainMessage<GrantResponse> | undefined, b: GrantResponse | PlainMessage<GrantResponse> | undefined): boolean {
    return proto3.util.equals(GrantResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListRolesRequest
 */
export class ListRolesRequest extends Message<ListRolesRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: bool as_resources = 2;
   */
  asResources = false;

  constructor(data?: PartialMessage<ListRolesRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListRolesRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "as_resources", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListRolesRequest {
    return new ListRolesRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListRolesRequest {
    return new ListRolesRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListRolesRequest {
    return new ListRolesRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListRolesRequest | PlainMessage<ListRolesRequest> | undefined, b: ListRolesRequest | PlainMessage<ListRolesRequest> | undefined): boolean {
    return proto3.util.equals(ListRolesRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListRolesResponse
 */
export class ListRolesResponse extends Message<ListRolesResponse> {
  /**
   * Note: oneof and repeated do not work together
   *
   * @generated from field: repeated github.com.akuity.kargo.api.rbac.v1alpha1.Role roles = 1;
   */
  roles: Role[] = [];

  /**
   * @generated from field: repeated github.com.akuity.kargo.api.rbac.v1alpha1.RoleResources resources = 2;
   */
  resources: RoleResources[] = [];

  constructor(data?: PartialMessage<ListRolesResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListRolesResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "roles", kind: "message", T: Role, repeated: true },
    { no: 2, name: "resources", kind: "message", T: RoleResources, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListRolesResponse {
    return new ListRolesResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListRolesResponse {
    return new ListRolesResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListRolesResponse {
    return new ListRolesResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListRolesResponse | PlainMessage<ListRolesResponse> | undefined, b: ListRolesResponse | PlainMessage<ListRolesResponse> | undefined): boolean {
    return proto3.util.equals(ListRolesResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.RevokeRequest
 */
export class RevokeRequest extends Message<RevokeRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string role = 2;
   */
  role = "";

  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.RevokeRequest.request
   */
  request: {
    /**
     * @generated from field: akuity.io.kargo.service.v1alpha1.Claims user_claims = 3;
     */
    value: Claims;
    case: "userClaims";
  } | {
    /**
     * @generated from field: github.com.akuity.kargo.api.rbac.v1alpha1.ResourceDetails resource_details = 4;
     */
    value: ResourceDetails;
    case: "resourceDetails";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<RevokeRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.RevokeRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "role", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "user_claims", kind: "message", T: Claims, oneof: "request" },
    { no: 4, name: "resource_details", kind: "message", T: ResourceDetails, oneof: "request" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RevokeRequest {
    return new RevokeRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RevokeRequest {
    return new RevokeRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RevokeRequest {
    return new RevokeRequest().fromJsonString(jsonString, options);
  }

  static equals(a: RevokeRequest | PlainMessage<RevokeRequest> | undefined, b: RevokeRequest | PlainMessage<RevokeRequest> | undefined): boolean {
    return proto3.util.equals(RevokeRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.RevokeResponse
 */
export class RevokeResponse extends Message<RevokeResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.rbac.v1alpha1.Role role = 1;
   */
  role?: Role;

  constructor(data?: PartialMessage<RevokeResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.RevokeResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "role", kind: "message", T: Role },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RevokeResponse {
    return new RevokeResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RevokeResponse {
    return new RevokeResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RevokeResponse {
    return new RevokeResponse().fromJsonString(jsonString, options);
  }

  static equals(a: RevokeResponse | PlainMessage<RevokeResponse> | undefined, b: RevokeResponse | PlainMessage<RevokeResponse> | undefined): boolean {
    return proto3.util.equals(RevokeResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.UpdateRoleRequest
 */
export class UpdateRoleRequest extends Message<UpdateRoleRequest> {
  /**
   * @generated from field: github.com.akuity.kargo.api.rbac.v1alpha1.Role role = 1;
   */
  role?: Role;

  constructor(data?: PartialMessage<UpdateRoleRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.UpdateRoleRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "role", kind: "message", T: Role },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateRoleRequest {
    return new UpdateRoleRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateRoleRequest {
    return new UpdateRoleRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateRoleRequest {
    return new UpdateRoleRequest().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateRoleRequest | PlainMessage<UpdateRoleRequest> | undefined, b: UpdateRoleRequest | PlainMessage<UpdateRoleRequest> | undefined): boolean {
    return proto3.util.equals(UpdateRoleRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.UpdateRoleResponse
 */
export class UpdateRoleResponse extends Message<UpdateRoleResponse> {
  /**
   * @generated from field: github.com.akuity.kargo.api.rbac.v1alpha1.Role role = 1;
   */
  role?: Role;

  constructor(data?: PartialMessage<UpdateRoleResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.UpdateRoleResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "role", kind: "message", T: Role },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateRoleResponse {
    return new UpdateRoleResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateRoleResponse {
    return new UpdateRoleResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateRoleResponse {
    return new UpdateRoleResponse().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateRoleResponse | PlainMessage<UpdateRoleResponse> | undefined, b: UpdateRoleResponse | PlainMessage<UpdateRoleResponse> | undefined): boolean {
    return proto3.util.equals(UpdateRoleResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListAnalysisTemplateConfigMapsRequest
 */
export class ListAnalysisTemplateConfigMapsRequest extends Message<ListAnalysisTemplateConfigMapsRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  constructor(data?: PartialMessage<ListAnalysisTemplateConfigMapsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListAnalysisTemplateConfigMapsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListAnalysisTemplateConfigMapsRequest {
    return new ListAnalysisTemplateConfigMapsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListAnalysisTemplateConfigMapsRequest {
    return new ListAnalysisTemplateConfigMapsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListAnalysisTemplateConfigMapsRequest {
    return new ListAnalysisTemplateConfigMapsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListAnalysisTemplateConfigMapsRequest | PlainMessage<ListAnalysisTemplateConfigMapsRequest> | undefined, b: ListAnalysisTemplateConfigMapsRequest | PlainMessage<ListAnalysisTemplateConfigMapsRequest> | undefined): boolean {
    return proto3.util.equals(ListAnalysisTemplateConfigMapsRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListAnalysisTemplateConfigMapsResponse
 */
export class ListAnalysisTemplateConfigMapsResponse extends Message<ListAnalysisTemplateConfigMapsResponse> {
  /**
   * @generated from field: repeated k8s.io.api.core.v1.ConfigMap config_maps = 1;
   */
  configMaps: ConfigMap[] = [];

  constructor(data?: PartialMessage<ListAnalysisTemplateConfigMapsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListAnalysisTemplateConfigMapsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "config_maps", kind: "message", T: ConfigMap, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListAnalysisTemplateConfigMapsResponse {
    return new ListAnalysisTemplateConfigMapsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListAnalysisTemplateConfigMapsResponse {
    return new ListAnalysisTemplateConfigMapsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListAnalysisTemplateConfigMapsResponse {
    return new ListAnalysisTemplateConfigMapsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListAnalysisTemplateConfigMapsResponse | PlainMessage<ListAnalysisTemplateConfigMapsResponse> | undefined, b: ListAnalysisTemplateConfigMapsResponse | PlainMessage<ListAnalysisTemplateConfigMapsResponse> | undefined): boolean {
    return proto3.util.equals(ListAnalysisTemplateConfigMapsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateConfigMapRequest
 */
export class GetAnalysisTemplateConfigMapRequest extends Message<GetAnalysisTemplateConfigMapRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 3;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetAnalysisTemplateConfigMapRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateConfigMapRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAnalysisTemplateConfigMapRequest {
    return new GetAnalysisTemplateConfigMapRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAnalysisTemplateConfigMapRequest {
    return new GetAnalysisTemplateConfigMapRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAnalysisTemplateConfigMapRequest {
    return new GetAnalysisTemplateConfigMapRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetAnalysisTemplateConfigMapRequest | PlainMessage<GetAnalysisTemplateConfigMapRequest> | undefined, b: GetAnalysisTemplateConfigMapRequest | PlainMessage<GetAnalysisTemplateConfigMapRequest> | undefined): boolean {
    return proto3.util.equals(GetAnalysisTemplateConfigMapRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateConfigMapResponse
 */
export class GetAnalysisTemplateConfigMapResponse extends Message<GetAnalysisTemplateConfigMapResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateConfigMapResponse.result
   */
  result: {
    /**
     * @generated from field: k8s.io.api.core.v1.ConfigMap config_map = 1;
     */
    value: ConfigMap;
    case: "configMap";
  } | {
    /**
     * @generated from field: bytes raw = 2;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetAnalysisTemplateConfigMapResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateConfigMapResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "config_map", kind: "message", T: ConfigMap, oneof: "result" },
    { no: 2, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAnalysisTemplateConfigMapResponse {
    return new GetAnalysisTemplateConfigMapResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAnalysisTemplateConfigMapResponse {
    return new GetAnalysisTemplateConfigMapResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAnalysisTemplateConfigMapResponse {
    return new GetAnalysisTemplateConfigMapResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetAnalysisTemplateConfigMapResponse | PlainMessage<GetAnalysisTemplateConfigMapResponse> | undefined, b: GetAnalysisTemplateConfigMapResponse | PlainMessage<GetAnalysisTemplateConfigMapResponse> | undefined): boolean {
    return proto3.util.equals(GetAnalysisTemplateConfigMapResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListAnalysisTemplateSecretsRequest
 */
export class ListAnalysisTemplateSecretsRequest extends Message<ListAnalysisTemplateSecretsRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  constructor(data?: PartialMessage<ListAnalysisTemplateSecretsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListAnalysisTemplateSecretsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListAnalysisTemplateSecretsRequest {
    return new ListAnalysisTemplateSecretsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListAnalysisTemplateSecretsRequest {
    return new ListAnalysisTemplateSecretsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListAnalysisTemplateSecretsRequest {
    return new ListAnalysisTemplateSecretsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListAnalysisTemplateSecretsRequest | PlainMessage<ListAnalysisTemplateSecretsRequest> | undefined, b: ListAnalysisTemplateSecretsRequest | PlainMessage<ListAnalysisTemplateSecretsRequest> | undefined): boolean {
    return proto3.util.equals(ListAnalysisTemplateSecretsRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.ListAnalysisTemplateSecretsResponse
 */
export class ListAnalysisTemplateSecretsResponse extends Message<ListAnalysisTemplateSecretsResponse> {
  /**
   * @generated from field: repeated k8s.io.api.core.v1.Secret secrets = 1;
   */
  secrets: Secret[] = [];

  constructor(data?: PartialMessage<ListAnalysisTemplateSecretsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.ListAnalysisTemplateSecretsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "secrets", kind: "message", T: Secret, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListAnalysisTemplateSecretsResponse {
    return new ListAnalysisTemplateSecretsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListAnalysisTemplateSecretsResponse {
    return new ListAnalysisTemplateSecretsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListAnalysisTemplateSecretsResponse {
    return new ListAnalysisTemplateSecretsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListAnalysisTemplateSecretsResponse | PlainMessage<ListAnalysisTemplateSecretsResponse> | undefined, b: ListAnalysisTemplateSecretsResponse | PlainMessage<ListAnalysisTemplateSecretsResponse> | undefined): boolean {
    return proto3.util.equals(ListAnalysisTemplateSecretsResponse, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateSecretRequest
 */
export class GetAnalysisTemplateSecretRequest extends Message<GetAnalysisTemplateSecretRequest> {
  /**
   * @generated from field: string project = 1;
   */
  project = "";

  /**
   * @generated from field: string name = 2;
   */
  name = "";

  /**
   * @generated from field: akuity.io.kargo.service.v1alpha1.RawFormat format = 3;
   */
  format = RawFormat.UNSPECIFIED;

  constructor(data?: PartialMessage<GetAnalysisTemplateSecretRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateSecretRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "project", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "format", kind: "enum", T: proto3.getEnumType(RawFormat) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAnalysisTemplateSecretRequest {
    return new GetAnalysisTemplateSecretRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAnalysisTemplateSecretRequest {
    return new GetAnalysisTemplateSecretRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAnalysisTemplateSecretRequest {
    return new GetAnalysisTemplateSecretRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetAnalysisTemplateSecretRequest | PlainMessage<GetAnalysisTemplateSecretRequest> | undefined, b: GetAnalysisTemplateSecretRequest | PlainMessage<GetAnalysisTemplateSecretRequest> | undefined): boolean {
    return proto3.util.equals(GetAnalysisTemplateSecretRequest, a, b);
  }
}

/**
 * @generated from message akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateSecretResponse
 */
export class GetAnalysisTemplateSecretResponse extends Message<GetAnalysisTemplateSecretResponse> {
  /**
   * @generated from oneof akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateSecretResponse.result
   */
  result: {
    /**
     * @generated from field: k8s.io.api.core.v1.Secret secret = 1;
     */
    value: Secret;
    case: "secret";
  } | {
    /**
     * @generated from field: bytes raw = 2;
     */
    value: Uint8Array;
    case: "raw";
  } | { case: undefined; value?: undefined } = { case: undefined };

  constructor(data?: PartialMessage<GetAnalysisTemplateSecretResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "akuity.io.kargo.service.v1alpha1.GetAnalysisTemplateSecretResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "secret", kind: "message", T: Secret, oneof: "result" },
    { no: 2, name: "raw", kind: "scalar", T: 12 /* ScalarType.BYTES */, oneof: "result" },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetAnalysisTemplateSecretResponse {
    return new GetAnalysisTemplateSecretResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetAnalysisTemplateSecretResponse {
    return new GetAnalysisTemplateSecretResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetAnalysisTemplateSecretResponse {
    return new GetAnalysisTemplateSecretResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetAnalysisTemplateSecretResponse | PlainMessage<GetAnalysisTemplateSecretResponse> | undefined, b: GetAnalysisTemplateSecretResponse | PlainMessage<GetAnalysisTemplateSecretResponse> | undefined): boolean {
    return proto3.util.equals(GetAnalysisTemplateSecretResponse, a, b);
  }
}

