// @generated by protoc-gen-es v1.10.0 with parameter "target=ts,import_extension=none"
// @generated from file types/v1/localhost_config.proto (package types.v1, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64, Struct } from "@bufbuild/protobuf";

/**
 * @generated from message types.v1.FormatConfig
 */
export class FormatConfig extends Message<FormatConfig> {
  /**
   * @generated from field: types.v1.FormatConfig.Themes themes = 1;
   */
  themes?: FormatConfig_Themes;

  /**
   * @generated from field: repeated string skip_fields = 2;
   */
  skipFields: string[] = [];

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

  /**
   * @generated from field: optional bool sort_longest = 4;
   */
  sortLongest?: boolean;

  /**
   * @generated from field: optional bool skip_unchanged = 5;
   */
  skipUnchanged?: boolean;

  /**
   * @generated from field: optional types.v1.FormatConfig.Truncation truncation = 6;
   */
  truncation?: FormatConfig_Truncation;

  /**
   * @generated from field: optional types.v1.FormatConfig.Time time = 7;
   */
  time?: FormatConfig_Time;

  /**
   * @generated from field: optional types.v1.FormatConfig.Message message = 8;
   */
  message?: FormatConfig_Message;

  /**
   * @generated from field: optional types.v1.FormatConfig.ColorMode terminal_color_mode = 9;
   */
  terminalColorMode?: FormatConfig_ColorMode;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.FormatConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "themes", kind: "message", T: FormatConfig_Themes },
    { no: 2, name: "skip_fields", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 3, name: "keep_fields", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 4, name: "sort_longest", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 5, name: "skip_unchanged", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 6, name: "truncation", kind: "message", T: FormatConfig_Truncation, opt: true },
    { no: 7, name: "time", kind: "message", T: FormatConfig_Time, opt: true },
    { no: 8, name: "message", kind: "message", T: FormatConfig_Message, opt: true },
    { no: 9, name: "terminal_color_mode", kind: "enum", T: proto3.getEnumType(FormatConfig_ColorMode), opt: true },
  ]);

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

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

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

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

/**
 * @generated from enum types.v1.FormatConfig.ColorMode
 */
export enum FormatConfig_ColorMode {
  /**
   * @generated from enum value: COLORMODE_AUTO = 0;
   */
  COLORMODE_AUTO = 0,

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

  /**
   * @generated from enum value: COLORMODE_DISABLED = 2;
   */
  COLORMODE_DISABLED = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(FormatConfig_ColorMode)
proto3.util.setEnumType(FormatConfig_ColorMode, "types.v1.FormatConfig.ColorMode", [
  { no: 0, name: "COLORMODE_AUTO" },
  { no: 1, name: "COLORMODE_ENABLED" },
  { no: 2, name: "COLORMODE_DISABLED" },
]);

/**
 * @generated from message types.v1.FormatConfig.Color
 */
export class FormatConfig_Color extends Message<FormatConfig_Color> {
  /**
   * @generated from field: string html_hex_color = 1;
   */
  htmlHexColor = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.FormatConfig.Color";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "html_hex_color", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.FormatConfig.Style
 */
export class FormatConfig_Style extends Message<FormatConfig_Style> {
  /**
   * @generated from field: types.v1.FormatConfig.Color foreground = 1;
   */
  foreground?: FormatConfig_Color;

  /**
   * @generated from field: optional types.v1.FormatConfig.Color background = 2;
   */
  background?: FormatConfig_Color;

  /**
   * ANSI text formatting
   *
   * @generated from field: optional bool bold = 300;
   */
  bold?: boolean;

  /**
   * @generated from field: optional bool italic = 301;
   */
  italic?: boolean;

  /**
   * @generated from field: optional bool faint = 302;
   */
  faint?: boolean;

  /**
   * @generated from field: optional bool blink = 303;
   */
  blink?: boolean;

  /**
   * @generated from field: optional bool strikethrough = 304;
   */
  strikethrough?: boolean;

  /**
   * @generated from field: optional bool underline = 305;
   */
  underline?: boolean;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.FormatConfig.Style";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "foreground", kind: "message", T: FormatConfig_Color },
    { no: 2, name: "background", kind: "message", T: FormatConfig_Color, opt: true },
    { no: 300, name: "bold", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 301, name: "italic", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 302, name: "faint", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 303, name: "blink", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 304, name: "strikethrough", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 305, name: "underline", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.FormatConfig.NullStyle
 */
export class FormatConfig_NullStyle extends Message<FormatConfig_NullStyle> {
  /**
   * @generated from field: types.v1.FormatConfig.Style style = 1;
   */
  style?: FormatConfig_Style;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.FormatConfig.NullStyle";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "style", kind: "message", T: FormatConfig_Style },
    { no: 2, name: "content", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.FormatConfig.LevelStyle
 */
export class FormatConfig_LevelStyle extends Message<FormatConfig_LevelStyle> {
  /**
   * @generated from field: types.v1.FormatConfig.Style debug = 100;
   */
  debug?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.Style info = 200;
   */
  info?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.Style warn = 300;
   */
  warn?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.Style error = 400;
   */
  error?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.Style panic = 500;
   */
  panic?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.Style fatal = 600;
   */
  fatal?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.Style unknown = 700;
   */
  unknown?: FormatConfig_Style;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.FormatConfig.LevelStyle";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 100, name: "debug", kind: "message", T: FormatConfig_Style },
    { no: 200, name: "info", kind: "message", T: FormatConfig_Style },
    { no: 300, name: "warn", kind: "message", T: FormatConfig_Style },
    { no: 400, name: "error", kind: "message", T: FormatConfig_Style },
    { no: 500, name: "panic", kind: "message", T: FormatConfig_Style },
    { no: 600, name: "fatal", kind: "message", T: FormatConfig_Style },
    { no: 700, name: "unknown", kind: "message", T: FormatConfig_Style },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.FormatConfig.Theme
 */
export class FormatConfig_Theme extends Message<FormatConfig_Theme> {
  /**
   * @generated from field: types.v1.FormatConfig.Style key = 1;
   */
  key?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.Style value = 2;
   */
  value?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.Style time = 3;
   */
  time?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.Style msg = 4;
   */
  msg?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.LevelStyle levels = 5;
   */
  levels?: FormatConfig_LevelStyle;

  /**
   * how to style messages that are missing
   *
   * @generated from field: types.v1.FormatConfig.Style absent_msg = 6;
   */
  absentMsg?: FormatConfig_Style;

  /**
   * @generated from field: types.v1.FormatConfig.Style absent_time = 7;
   */
  absentTime?: FormatConfig_Style;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.FormatConfig.Theme";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "key", kind: "message", T: FormatConfig_Style },
    { no: 2, name: "value", kind: "message", T: FormatConfig_Style },
    { no: 3, name: "time", kind: "message", T: FormatConfig_Style },
    { no: 4, name: "msg", kind: "message", T: FormatConfig_Style },
    { no: 5, name: "levels", kind: "message", T: FormatConfig_LevelStyle },
    { no: 6, name: "absent_msg", kind: "message", T: FormatConfig_Style },
    { no: 7, name: "absent_time", kind: "message", T: FormatConfig_Style },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.FormatConfig.Themes
 */
export class FormatConfig_Themes extends Message<FormatConfig_Themes> {
  /**
   * @generated from field: types.v1.FormatConfig.Theme light = 1;
   */
  light?: FormatConfig_Theme;

  /**
   * @generated from field: types.v1.FormatConfig.Theme dark = 2;
   */
  dark?: FormatConfig_Theme;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.FormatConfig.Themes";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "light", kind: "message", T: FormatConfig_Theme },
    { no: 2, name: "dark", kind: "message", T: FormatConfig_Theme },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.FormatConfig.Truncation
 */
export class FormatConfig_Truncation extends Message<FormatConfig_Truncation> {
  /**
   * @generated from field: int64 length = 1;
   */
  length = protoInt64.zero;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.FormatConfig.Truncation";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "length", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.FormatConfig.Time
 */
export class FormatConfig_Time extends Message<FormatConfig_Time> {
  /**
   * @generated from field: optional string format = 1;
   */
  format?: string;

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.FormatConfig.Time";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "format", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 2, name: "timezone", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 3, name: "absent_default_value", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.FormatConfig.Message
 */
export class FormatConfig_Message extends Message<FormatConfig_Message> {
  /**
   * @generated from field: optional string absent_default_value = 1;
   */
  absentDefaultValue?: string;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.FormatConfig.Message";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "absent_default_value", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.ParseConfig
 */
export class ParseConfig extends Message<ParseConfig> {
  /**
   * @generated from field: types.v1.ParseConfig.Time timestamp = 1;
   */
  timestamp?: ParseConfig_Time;

  /**
   * @generated from field: types.v1.ParseConfig.Message message = 2;
   */
  message?: ParseConfig_Message;

  /**
   * @generated from field: types.v1.ParseConfig.Level level = 3;
   */
  level?: ParseConfig_Level;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.ParseConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "timestamp", kind: "message", T: ParseConfig_Time },
    { no: 2, name: "message", kind: "message", T: ParseConfig_Message },
    { no: 3, name: "level", kind: "message", T: ParseConfig_Level },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.ParseConfig.Time
 */
export class ParseConfig_Time extends Message<ParseConfig_Time> {
  /**
   * @generated from field: repeated string field_names = 1;
   */
  fieldNames: string[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.ParseConfig.Time";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "field_names", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.ParseConfig.Message
 */
export class ParseConfig_Message extends Message<ParseConfig_Message> {
  /**
   * @generated from field: repeated string field_names = 1;
   */
  fieldNames: string[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.ParseConfig.Message";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "field_names", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.ParseConfig.Level
 */
export class ParseConfig_Level extends Message<ParseConfig_Level> {
  /**
   * @generated from field: repeated string field_names = 1;
   */
  fieldNames: string[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.ParseConfig.Level";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "field_names", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.ServeLocalhostConfig
 */
export class ServeLocalhostConfig extends Message<ServeLocalhostConfig> {
  /**
   * @generated from field: int64 port = 1;
   */
  port = protoInt64.zero;

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

  /**
   * @generated from field: google.protobuf.Struct engine_config = 3;
   */
  engineConfig?: Struct;

  /**
   * @generated from field: optional bool show_in_systray = 4;
   */
  showInSystray?: boolean;

  /**
   * @generated from field: optional string log_dir = 5;
   */
  logDir?: string;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.ServeLocalhostConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "port", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 2, name: "engine", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "engine_config", kind: "message", T: Struct },
    { no: 4, name: "show_in_systray", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 5, name: "log_dir", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.RuntimeConfig
 */
export class RuntimeConfig extends Message<RuntimeConfig> {
  /**
   * @generated from field: optional bool interrupt = 1;
   */
  interrupt?: boolean;

  /**
   * @generated from field: optional bool skip_check_for_updates = 2;
   */
  skipCheckForUpdates?: boolean;

  /**
   * @generated from field: types.v1.RuntimeConfig.Features features = 3;
   */
  features?: RuntimeConfig_Features;

  /**
   * @generated from field: types.v1.RuntimeConfig.ExperimentalFeatures experimental_features = 4;
   */
  experimentalFeatures?: RuntimeConfig_ExperimentalFeatures;

  /**
   * @generated from field: types.v1.RuntimeConfig.ClientConfig api_client = 5;
   */
  apiClient?: RuntimeConfig_ClientConfig;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.RuntimeConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "interrupt", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 2, name: "skip_check_for_updates", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 3, name: "features", kind: "message", T: RuntimeConfig_Features },
    { no: 4, name: "experimental_features", kind: "message", T: RuntimeConfig_ExperimentalFeatures },
    { no: 5, name: "api_client", kind: "message", T: RuntimeConfig_ClientConfig },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.RuntimeConfig.Features
 */
export class RuntimeConfig_Features extends Message<RuntimeConfig_Features> {
  constructor(data?: PartialMessage<RuntimeConfig_Features>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.RuntimeConfig.Features";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

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

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

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

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

/**
 * @generated from message types.v1.RuntimeConfig.ExperimentalFeatures
 */
export class RuntimeConfig_ExperimentalFeatures extends Message<RuntimeConfig_ExperimentalFeatures> {
  /**
   * @generated from field: optional string release_channel = 1;
   */
  releaseChannel?: string;

  /**
   * @generated from field: optional bool send_logs_to_cloud = 2;
   */
  sendLogsToCloud?: boolean;

  /**
   * @generated from field: optional types.v1.ServeLocalhostConfig serve_localhost = 3;
   */
  serveLocalhost?: ServeLocalhostConfig;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.RuntimeConfig.ExperimentalFeatures";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "release_channel", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 2, name: "send_logs_to_cloud", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 3, name: "serve_localhost", kind: "message", T: ServeLocalhostConfig, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message types.v1.RuntimeConfig.ClientConfig
 */
export class RuntimeConfig_ClientConfig extends Message<RuntimeConfig_ClientConfig> {
  /**
   * @generated from field: optional types.v1.RuntimeConfig.ClientConfig.HTTPProtocol http_protocol = 1;
   */
  httpProtocol?: RuntimeConfig_ClientConfig_HTTPProtocol;

  /**
   * @generated from field: optional types.v1.RuntimeConfig.ClientConfig.RPCProtocol rpc_protocol = 2;
   */
  rpcProtocol?: RuntimeConfig_ClientConfig_RPCProtocol;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.RuntimeConfig.ClientConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "http_protocol", kind: "enum", T: proto3.getEnumType(RuntimeConfig_ClientConfig_HTTPProtocol), opt: true },
    { no: 2, name: "rpc_protocol", kind: "enum", T: proto3.getEnumType(RuntimeConfig_ClientConfig_RPCProtocol), opt: true },
  ]);

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

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

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

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

/**
 * @generated from enum types.v1.RuntimeConfig.ClientConfig.HTTPProtocol
 */
export enum RuntimeConfig_ClientConfig_HTTPProtocol {
  /**
   * @generated from enum value: HTTP2 = 0;
   */
  HTTP2 = 0,

  /**
   * @generated from enum value: HTTP1 = 1;
   */
  HTTP1 = 1,
}
// Retrieve enum metadata with: proto3.getEnumType(RuntimeConfig_ClientConfig_HTTPProtocol)
proto3.util.setEnumType(RuntimeConfig_ClientConfig_HTTPProtocol, "types.v1.RuntimeConfig.ClientConfig.HTTPProtocol", [
  { no: 0, name: "HTTP2" },
  { no: 1, name: "HTTP1" },
]);

/**
 * @generated from enum types.v1.RuntimeConfig.ClientConfig.RPCProtocol
 */
export enum RuntimeConfig_ClientConfig_RPCProtocol {
  /**
   * @generated from enum value: GRPC = 0;
   */
  GRPC = 0,

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

  /**
   * @generated from enum value: PROTOJSON = 2;
   */
  PROTOJSON = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(RuntimeConfig_ClientConfig_RPCProtocol)
proto3.util.setEnumType(RuntimeConfig_ClientConfig_RPCProtocol, "types.v1.RuntimeConfig.ClientConfig.RPCProtocol", [
  { no: 0, name: "GRPC" },
  { no: 1, name: "GRPC_WEB" },
  { no: 2, name: "PROTOJSON" },
]);

/**
 * @generated from message types.v1.LocalhostConfig
 */
export class LocalhostConfig extends Message<LocalhostConfig> {
  /**
   * @generated from field: int64 version = 1;
   */
  version = protoInt64.zero;

  /**
   * @generated from field: types.v1.FormatConfig formatter = 2;
   */
  formatter?: FormatConfig;

  /**
   * @generated from field: types.v1.ParseConfig parser = 3;
   */
  parser?: ParseConfig;

  /**
   * @generated from field: types.v1.RuntimeConfig runtime = 4;
   */
  runtime?: RuntimeConfig;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "types.v1.LocalhostConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "version", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 2, name: "formatter", kind: "message", T: FormatConfig },
    { no: 3, name: "parser", kind: "message", T: ParseConfig },
    { no: 4, name: "runtime", kind: "message", T: RuntimeConfig },
  ]);

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

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

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

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

