github.com/GoogleCloudPlatform/testgrid@v0.0.174/web/src/gen/pb/state/state.ts (about)

     1  // @generated by protobuf-ts 2.8.3 with parameter long_type_string
     2  // @generated from protobuf file "pb/state/state.proto" (package "testgrid.state", syntax proto3)
     3  // tslint:disable
     4  import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
     5  import type { IBinaryWriter } from "@protobuf-ts/runtime";
     6  import { WireType } from "@protobuf-ts/runtime";
     7  import type { BinaryReadOptions } from "@protobuf-ts/runtime";
     8  import type { IBinaryReader } from "@protobuf-ts/runtime";
     9  import { UnknownFieldHandler } from "@protobuf-ts/runtime";
    10  import type { PartialMessage } from "@protobuf-ts/runtime";
    11  import { reflectionMergePartial } from "@protobuf-ts/runtime";
    12  import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
    13  import { MessageType } from "@protobuf-ts/runtime";
    14  import { TestGroup } from "../config/config";
    15  import { Timestamp } from "../../google/protobuf/timestamp";
    16  /**
    17   * @generated from protobuf message testgrid.state.Property
    18   */
    19  export interface Property {
    20      /**
    21       * @generated from protobuf field: map<string, string> property = 1;
    22       */
    23      property: {
    24          [key: string]: string;
    25      };
    26  }
    27  /**
    28   * A metric and its values for each test cycle.
    29   *
    30   * @generated from protobuf message testgrid.state.Metric
    31   */
    32  export interface Metric {
    33      /**
    34       * @generated from protobuf field: string name = 1;
    35       */
    36      name: string; // Name of metric, such as duration
    37      /**
    38       * Sparse encoding of values. Indices is a list of pairs of <index, count>
    39       * that details columns with metric values. So given:
    40       *   Indices: [0, 2, 6, 4]
    41       *   Values: [0.1,0.2,6.1,6.2,6.3,6.4]
    42       * Decoded 12-value equivalent is:
    43       * [0.1, 0.2, nil, nil, nil, nil, 6.1, 6.2, 6.3, 6.4, nil, nil, ...]
    44       *
    45       * @generated from protobuf field: repeated int32 indices = 2;
    46       */
    47      indices: number[]; // n=index of first value, n+1=count of filled values
    48      /**
    49       * @generated from protobuf field: repeated double values = 3;
    50       */
    51      values: number[]; // only present for columns with a metric value
    52  }
    53  /**
    54   * @generated from protobuf message testgrid.state.UpdatePhaseData
    55   */
    56  export interface UpdatePhaseData {
    57      /**
    58       * The name for a part of the update cycle.
    59       *
    60       * @generated from protobuf field: string phase_name = 1;
    61       */
    62      phaseName: string;
    63      /**
    64       * Time taken for a part of the update cycle, in seconds.
    65       *
    66       * @generated from protobuf field: double phase_seconds = 2;
    67       */
    68      phaseSeconds: number;
    69  }
    70  /**
    71   * Info on time taken to update test results during the last update cycle.
    72   *
    73   * @generated from protobuf message testgrid.state.UpdateInfo
    74   */
    75  export interface UpdateInfo {
    76      /**
    77       * Metrics for how long parts of the update cycle take.
    78       *
    79       * @generated from protobuf field: repeated testgrid.state.UpdatePhaseData update_phase_data = 1;
    80       */
    81      updatePhaseData: UpdatePhaseData[];
    82  }
    83  /**
    84   * Info on a failing test row about the failure.
    85   *
    86   * @generated from protobuf message testgrid.state.AlertInfo
    87   */
    88  export interface AlertInfo {
    89      /**
    90       * Number of results that have failed.
    91       *
    92       * @generated from protobuf field: int32 fail_count = 1;
    93       */
    94      failCount: number;
    95      /**
    96       * The build ID the test first failed at.
    97       *
    98       * @generated from protobuf field: string fail_build_id = 2;
    99       */
   100      failBuildId: string;
   101      /**
   102       * The time the test first failed at.
   103       *
   104       * @generated from protobuf field: google.protobuf.Timestamp fail_time = 3;
   105       */
   106      failTime?: Timestamp;
   107      /**
   108       * The test ID for the first test failure.
   109       *
   110       * @generated from protobuf field: string fail_test_id = 4;
   111       */
   112      failTestId: string;
   113      /**
   114       * The build ID the test last passed at.
   115       *
   116       * @generated from protobuf field: string pass_build_id = 5;
   117       */
   118      passBuildId: string;
   119      /**
   120       * The time the test last passed at.
   121       *
   122       * @generated from protobuf field: google.protobuf.Timestamp pass_time = 6;
   123       */
   124      passTime?: Timestamp;
   125      /**
   126       * A snippet explaining the failure.
   127       *
   128       * @generated from protobuf field: string failure_message = 7;
   129       */
   130      failureMessage: string;
   131      /**
   132       * Link to search for build changes, internally a code-search link.
   133       *
   134       * @generated from protobuf field: string build_link = 8;
   135       */
   136      buildLink: string;
   137      /**
   138       * Text for option to search for build changes.
   139       *
   140       * @generated from protobuf field: string build_link_text = 9;
   141       */
   142      buildLinkText: string;
   143      /**
   144       * Text to display for link to search for build changes.
   145       *
   146       * @generated from protobuf field: string build_url_text = 10;
   147       */
   148      buildUrlText: string;
   149      /**
   150       * The build ID for the latest test failure. (Does not indicate the failure is
   151       * 'over', just the latest test failure we found.)
   152       *
   153       * @generated from protobuf field: string latest_fail_build_id = 11;
   154       */
   155      latestFailBuildId: string;
   156      /**
   157       * The test ID for the latest test failure.
   158       *
   159       * @generated from protobuf field: string latest_fail_test_id = 14;
   160       */
   161      latestFailTestId: string;
   162      /**
   163       * Maps (property name):(property value) for arbitrary alert properties.
   164       *
   165       * @generated from protobuf field: map<string, string> properties = 12;
   166       */
   167      properties: {
   168          [key: string]: string;
   169      };
   170      /**
   171       * A list of IDs for issue hotlists related to this failure.
   172       *
   173       * @generated from protobuf field: repeated string hotlist_ids = 13;
   174       */
   175      hotlistIds: string[];
   176      /**
   177       * Dynamic email list, route email alerts to these instead of the configured
   178       * defaults.
   179       *
   180       * @generated from protobuf field: repeated string email_addresses = 15;
   181       */
   182      emailAddresses: string[];
   183  }
   184  /**
   185   * Info on default test metadata for a dashboard tab.
   186   *
   187   * @generated from protobuf message testgrid.state.TestMetadata
   188   */
   189  export interface TestMetadata {
   190      /**
   191       * Name of the test with associated test metadata.
   192       *
   193       * @generated from protobuf field: string test_name = 1;
   194       */
   195      testName: string;
   196      /**
   197       * Default bug component.
   198       *
   199       * @generated from protobuf field: int32 bug_component = 2;
   200       */
   201      bugComponent: number;
   202      /**
   203       * Default owner.
   204       *
   205       * @generated from protobuf field: string owner = 3;
   206       */
   207      owner: string;
   208      /**
   209       * Default list of cc's.
   210       *
   211       * @generated from protobuf field: repeated string cc = 4;
   212       */
   213      cc: string[];
   214      /**
   215       * When present, only file a bug for failed tests with same error type.
   216       * Otherwise, always file a bug.
   217       *
   218       * @generated from protobuf field: string error_type = 5;
   219       */
   220      errorType: string;
   221  }
   222  /**
   223   * TestGrid column headers. Does not contain the individual cells.
   224   *
   225   * @generated from protobuf message testgrid.state.Column
   226   */
   227  export interface Column {
   228      /**
   229       * Unique instance of the job, typically BUILD_NUMBER from prow or a guid
   230       *
   231       * @generated from protobuf field: string build = 1;
   232       */
   233      build: string;
   234      /**
   235       * Name associated with the column (such as the run/invocation ID).No two
   236       * columns should have the same build_id and name. The name field allows the
   237       * display of multiple columns with the same build_id.
   238       *
   239       * @generated from protobuf field: string name = 2;
   240       */
   241      name: string;
   242      /**
   243       * Milliseconds since start of epoch (python time.time() * 1000)
   244       * TODO(#683): Use a timestamp, not this double
   245       *
   246       * @generated from protobuf field: double started = 3;
   247       */
   248      started: number;
   249      /**
   250       * Additional custom headers like commit, image used, etc.
   251       *
   252       * @generated from protobuf field: repeated string extra = 4;
   253       */
   254      extra: string[];
   255      /**
   256       * Custom hotlist ids.
   257       *
   258       * @generated from protobuf field: string hotlist_ids = 5;
   259       */
   260      hotlistIds: string;
   261      /**
   262       * An optional hint for the updater.
   263       *
   264       * @generated from protobuf field: string hint = 6;
   265       */
   266      hint: string;
   267      /**
   268       * Dynamic email list, route email alerts to these instead of the configured
   269       * defaults.
   270       *
   271       * @generated from protobuf field: repeated string email_addresses = 7;
   272       */
   273      emailAddresses: string[];
   274      /**
   275       * Status totals for the column.
   276       * Only written in tab state, if a broken threshold is defined for columns.
   277       *
   278       * @generated from protobuf field: testgrid.state.Stats stats = 8;
   279       */
   280      stats?: Stats;
   281  }
   282  /**
   283   * @generated from protobuf message testgrid.state.Stats
   284   */
   285  export interface Stats {
   286      /**
   287       * @generated from protobuf field: int32 fail_count = 1;
   288       */
   289      failCount: number;
   290      /**
   291       * @generated from protobuf field: int32 pass_count = 2;
   292       */
   293      passCount: number;
   294      /**
   295       * @generated from protobuf field: int32 total_count = 3;
   296       */
   297      totalCount: number;
   298      /**
   299       * True if this column has any in-progress runs.
   300       *
   301       * @generated from protobuf field: bool pending = 4;
   302       */
   303      pending: boolean;
   304      /**
   305       * True if a broken threshold is defined, and this column's fail/total ratio
   306       * exceeds it.
   307       *
   308       * @generated from protobuf field: bool broken = 5;
   309       */
   310      broken: boolean;
   311  }
   312  /**
   313   * TestGrid rows
   314   *
   315   * @generated from protobuf message testgrid.state.Row
   316   */
   317  export interface Row {
   318      /**
   319       * Display name, which might process id to append/filter info.
   320       *
   321       * @generated from protobuf field: string name = 1;
   322       */
   323      name: string;
   324      /**
   325       * raw id for the row, such as the bazel target or golang package.
   326       *
   327       * @generated from protobuf field: string id = 2;
   328       */
   329      id: string;
   330      /**
   331       * Results for this row, run-length encoded to reduce size/improve
   332       * performance. Thus (encoded -> decoded equivalent):
   333       *   [0, 3, 5, 4] -> [0, 0, 0, 5, 5, 5, 5]
   334       *   [5, 1] -> [5]
   335       *   [1, 5] -> [1, 1, 1, 1, 1]
   336       * The decoded values are Result enums
   337       *
   338       * @generated from protobuf field: repeated int32 results = 3;
   339       */
   340      results: number[];
   341      /**
   342       * Test IDs for each test result in this test case.
   343       * Must be present on every column, regardless of status.
   344       *
   345       * @generated from protobuf field: repeated string cell_ids = 4;
   346       */
   347      cellIds: string[];
   348      /**
   349       * Short description of the result, displayed on mouseover.
   350       * Present for any column with a non-empty status (not NO_RESULT).
   351       *
   352       * @generated from protobuf field: repeated string messages = 5;
   353       */
   354      messages: string[];
   355      /**
   356       * Names of metrics associated with this test case. Stored separate from
   357       * metric info (which may be omitted).
   358       *
   359       * @generated from protobuf field: repeated string metric = 7;
   360       */
   361      metric: string[];
   362      /**
   363       * @generated from protobuf field: repeated testgrid.state.Metric metrics = 8;
   364       */
   365      metrics: Metric[]; // Numerical performance/timing data, etc.
   366      /**
   367       * Short string to place inside the cell (F for fail, etc)
   368       * Present for any column with a non-empty status (not NO_RESULT).
   369       *
   370       * @generated from protobuf field: repeated string icons = 9;
   371       */
   372      icons: string[];
   373      /**
   374       * IDs for issues associated with this row.
   375       *
   376       * @generated from protobuf field: repeated string issues = 10;
   377       */
   378      issues: string[];
   379      /**
   380       * An alert for the failure if there's a recent failure for this row.
   381       *
   382       * @generated from protobuf field: testgrid.state.AlertInfo alert_info = 11;
   383       */
   384      alertInfo?: AlertInfo;
   385      /**
   386       * Values of a user-defined property found in cells for this row.
   387       * TODO: Fold this into `properties` field.
   388       *
   389       * @generated from protobuf field: repeated string user_property = 12;
   390       */
   391      userProperty: string[];
   392      /**
   393       * General key-value pairs associated with cells in this row.
   394       * Present for any column with a non-empty status (not NO_RESULT).
   395       *
   396       * @generated from protobuf field: repeated testgrid.state.Property properties = 13;
   397       */
   398      properties: Property[];
   399  }
   400  /**
   401   * A single table of test results backing a dashboard tab.
   402   *
   403   * @generated from protobuf message testgrid.state.Grid
   404   */
   405  export interface Grid {
   406      /**
   407       * A cycle of test results, not including the results. In the TestGrid client,
   408       * the cycles define the columns.
   409       *
   410       * @generated from protobuf field: repeated testgrid.state.Column columns = 1;
   411       */
   412      columns: Column[];
   413      /**
   414       * A test case with test results. In the TestGrid client, the cases define the
   415       * rows (and the results define the individual cells).
   416       *
   417       * @generated from protobuf field: repeated testgrid.state.Row rows = 2;
   418       */
   419      rows: Row[];
   420      /**
   421       * The latest configuration used to generate this test group.
   422       *
   423       * @generated from protobuf field: testgrid.config.TestGroup config = 4;
   424       */
   425      config?: TestGroup;
   426      /**
   427       * Seconds since epoch for last time this cycle was updated.
   428       *
   429       * @generated from protobuf field: double last_time_updated = 6;
   430       */
   431      lastTimeUpdated: number;
   432      /**
   433       * Stored info on previous timing for parts of the update cycle.
   434       *
   435       * @generated from protobuf field: repeated testgrid.state.UpdateInfo update_info = 8;
   436       */
   437      updateInfo: UpdateInfo[];
   438      /**
   439       * Stored info on default test metadata.
   440       *
   441       * @generated from protobuf field: repeated testgrid.state.TestMetadata test_metadata = 9;
   442       */
   443      testMetadata: TestMetadata[];
   444      /**
   445       * Clusters of failures for a TestResultTable instance.
   446       *
   447       * @generated from protobuf field: repeated testgrid.state.Cluster cluster = 10;
   448       */
   449      cluster: Cluster[];
   450      /**
   451       * Most recent timestamp that clusters have processed.
   452       *
   453       * @generated from protobuf field: double most_recent_cluster_timestamp = 11;
   454       */
   455      mostRecentClusterTimestamp: number;
   456  }
   457  /**
   458   * A cluster of failures grouped by test status and message for a test results
   459   * table.
   460   *
   461   * @generated from protobuf message testgrid.state.Cluster
   462   */
   463  export interface Cluster {
   464      /**
   465       * Test status cluster grouped by.
   466       *
   467       * @generated from protobuf field: int32 test_status = 1;
   468       */
   469      testStatus: number;
   470      /**
   471       * Error message or testFailureClassification string cluster grouped by.
   472       *
   473       * @generated from protobuf field: string message = 2;
   474       */
   475      message: string;
   476      /**
   477       * ClusterRows that belong to this cluster.
   478       *
   479       * @generated from protobuf field: repeated testgrid.state.ClusterRow cluster_row = 3;
   480       */
   481      clusterRow: ClusterRow[];
   482  }
   483  /**
   484   * Cells in a TestRow that belong to a specific Cluster.
   485   *
   486   * @generated from protobuf message testgrid.state.ClusterRow
   487   */
   488  export interface ClusterRow {
   489      /**
   490       * Name of TestRow.
   491       *
   492       * @generated from protobuf field: string display_name = 1;
   493       */
   494      displayName: string;
   495      /**
   496       * Index within row that belongs to Cluster (refer to columns of the row).
   497       *
   498       * @generated from protobuf field: repeated int32 index = 2;
   499       */
   500      index: number[];
   501  }
   502  // @generated message type with reflection information, may provide speed optimized methods
   503  class Property$Type extends MessageType<Property> {
   504      constructor() {
   505          super("testgrid.state.Property", [
   506              { no: 1, name: "property", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } }
   507          ]);
   508      }
   509      create(value?: PartialMessage<Property>): Property {
   510          const message = { property: {} };
   511          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
   512          if (value !== undefined)
   513              reflectionMergePartial<Property>(this, message, value);
   514          return message;
   515      }
   516      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Property): Property {
   517          let message = target ?? this.create(), end = reader.pos + length;
   518          while (reader.pos < end) {
   519              let [fieldNo, wireType] = reader.tag();
   520              switch (fieldNo) {
   521                  case /* map<string, string> property */ 1:
   522                      this.binaryReadMap1(message.property, reader, options);
   523                      break;
   524                  default:
   525                      let u = options.readUnknownField;
   526                      if (u === "throw")
   527                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
   528                      let d = reader.skip(wireType);
   529                      if (u !== false)
   530                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
   531              }
   532          }
   533          return message;
   534      }
   535      private binaryReadMap1(map: Property["property"], reader: IBinaryReader, options: BinaryReadOptions): void {
   536          let len = reader.uint32(), end = reader.pos + len, key: keyof Property["property"] | undefined, val: Property["property"][any] | undefined;
   537          while (reader.pos < end) {
   538              let [fieldNo, wireType] = reader.tag();
   539              switch (fieldNo) {
   540                  case 1:
   541                      key = reader.string();
   542                      break;
   543                  case 2:
   544                      val = reader.string();
   545                      break;
   546                  default: throw new globalThis.Error("unknown map entry field for field testgrid.state.Property.property");
   547              }
   548          }
   549          map[key ?? ""] = val ?? "";
   550      }
   551      internalBinaryWrite(message: Property, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
   552          /* map<string, string> property = 1; */
   553          for (let k of Object.keys(message.property))
   554              writer.tag(1, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.property[k]).join();
   555          let u = options.writeUnknownFields;
   556          if (u !== false)
   557              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
   558          return writer;
   559      }
   560  }
   561  /**
   562   * @generated MessageType for protobuf message testgrid.state.Property
   563   */
   564  export const Property = new Property$Type();
   565  // @generated message type with reflection information, may provide speed optimized methods
   566  class Metric$Type extends MessageType<Metric> {
   567      constructor() {
   568          super("testgrid.state.Metric", [
   569              { no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   570              { no: 2, name: "indices", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 5 /*ScalarType.INT32*/ },
   571              { no: 3, name: "values", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 1 /*ScalarType.DOUBLE*/ }
   572          ]);
   573      }
   574      create(value?: PartialMessage<Metric>): Metric {
   575          const message = { name: "", indices: [], values: [] };
   576          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
   577          if (value !== undefined)
   578              reflectionMergePartial<Metric>(this, message, value);
   579          return message;
   580      }
   581      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Metric): Metric {
   582          let message = target ?? this.create(), end = reader.pos + length;
   583          while (reader.pos < end) {
   584              let [fieldNo, wireType] = reader.tag();
   585              switch (fieldNo) {
   586                  case /* string name */ 1:
   587                      message.name = reader.string();
   588                      break;
   589                  case /* repeated int32 indices */ 2:
   590                      if (wireType === WireType.LengthDelimited)
   591                          for (let e = reader.int32() + reader.pos; reader.pos < e;)
   592                              message.indices.push(reader.int32());
   593                      else
   594                          message.indices.push(reader.int32());
   595                      break;
   596                  case /* repeated double values */ 3:
   597                      if (wireType === WireType.LengthDelimited)
   598                          for (let e = reader.int32() + reader.pos; reader.pos < e;)
   599                              message.values.push(reader.double());
   600                      else
   601                          message.values.push(reader.double());
   602                      break;
   603                  default:
   604                      let u = options.readUnknownField;
   605                      if (u === "throw")
   606                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
   607                      let d = reader.skip(wireType);
   608                      if (u !== false)
   609                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
   610              }
   611          }
   612          return message;
   613      }
   614      internalBinaryWrite(message: Metric, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
   615          /* string name = 1; */
   616          if (message.name !== "")
   617              writer.tag(1, WireType.LengthDelimited).string(message.name);
   618          /* repeated int32 indices = 2; */
   619          if (message.indices.length) {
   620              writer.tag(2, WireType.LengthDelimited).fork();
   621              for (let i = 0; i < message.indices.length; i++)
   622                  writer.int32(message.indices[i]);
   623              writer.join();
   624          }
   625          /* repeated double values = 3; */
   626          if (message.values.length) {
   627              writer.tag(3, WireType.LengthDelimited).fork();
   628              for (let i = 0; i < message.values.length; i++)
   629                  writer.double(message.values[i]);
   630              writer.join();
   631          }
   632          let u = options.writeUnknownFields;
   633          if (u !== false)
   634              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
   635          return writer;
   636      }
   637  }
   638  /**
   639   * @generated MessageType for protobuf message testgrid.state.Metric
   640   */
   641  export const Metric = new Metric$Type();
   642  // @generated message type with reflection information, may provide speed optimized methods
   643  class UpdatePhaseData$Type extends MessageType<UpdatePhaseData> {
   644      constructor() {
   645          super("testgrid.state.UpdatePhaseData", [
   646              { no: 1, name: "phase_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   647              { no: 2, name: "phase_seconds", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ }
   648          ]);
   649      }
   650      create(value?: PartialMessage<UpdatePhaseData>): UpdatePhaseData {
   651          const message = { phaseName: "", phaseSeconds: 0 };
   652          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
   653          if (value !== undefined)
   654              reflectionMergePartial<UpdatePhaseData>(this, message, value);
   655          return message;
   656      }
   657      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdatePhaseData): UpdatePhaseData {
   658          let message = target ?? this.create(), end = reader.pos + length;
   659          while (reader.pos < end) {
   660              let [fieldNo, wireType] = reader.tag();
   661              switch (fieldNo) {
   662                  case /* string phase_name */ 1:
   663                      message.phaseName = reader.string();
   664                      break;
   665                  case /* double phase_seconds */ 2:
   666                      message.phaseSeconds = reader.double();
   667                      break;
   668                  default:
   669                      let u = options.readUnknownField;
   670                      if (u === "throw")
   671                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
   672                      let d = reader.skip(wireType);
   673                      if (u !== false)
   674                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
   675              }
   676          }
   677          return message;
   678      }
   679      internalBinaryWrite(message: UpdatePhaseData, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
   680          /* string phase_name = 1; */
   681          if (message.phaseName !== "")
   682              writer.tag(1, WireType.LengthDelimited).string(message.phaseName);
   683          /* double phase_seconds = 2; */
   684          if (message.phaseSeconds !== 0)
   685              writer.tag(2, WireType.Bit64).double(message.phaseSeconds);
   686          let u = options.writeUnknownFields;
   687          if (u !== false)
   688              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
   689          return writer;
   690      }
   691  }
   692  /**
   693   * @generated MessageType for protobuf message testgrid.state.UpdatePhaseData
   694   */
   695  export const UpdatePhaseData = new UpdatePhaseData$Type();
   696  // @generated message type with reflection information, may provide speed optimized methods
   697  class UpdateInfo$Type extends MessageType<UpdateInfo> {
   698      constructor() {
   699          super("testgrid.state.UpdateInfo", [
   700              { no: 1, name: "update_phase_data", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => UpdatePhaseData }
   701          ]);
   702      }
   703      create(value?: PartialMessage<UpdateInfo>): UpdateInfo {
   704          const message = { updatePhaseData: [] };
   705          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
   706          if (value !== undefined)
   707              reflectionMergePartial<UpdateInfo>(this, message, value);
   708          return message;
   709      }
   710      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UpdateInfo): UpdateInfo {
   711          let message = target ?? this.create(), end = reader.pos + length;
   712          while (reader.pos < end) {
   713              let [fieldNo, wireType] = reader.tag();
   714              switch (fieldNo) {
   715                  case /* repeated testgrid.state.UpdatePhaseData update_phase_data */ 1:
   716                      message.updatePhaseData.push(UpdatePhaseData.internalBinaryRead(reader, reader.uint32(), options));
   717                      break;
   718                  default:
   719                      let u = options.readUnknownField;
   720                      if (u === "throw")
   721                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
   722                      let d = reader.skip(wireType);
   723                      if (u !== false)
   724                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
   725              }
   726          }
   727          return message;
   728      }
   729      internalBinaryWrite(message: UpdateInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
   730          /* repeated testgrid.state.UpdatePhaseData update_phase_data = 1; */
   731          for (let i = 0; i < message.updatePhaseData.length; i++)
   732              UpdatePhaseData.internalBinaryWrite(message.updatePhaseData[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
   733          let u = options.writeUnknownFields;
   734          if (u !== false)
   735              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
   736          return writer;
   737      }
   738  }
   739  /**
   740   * @generated MessageType for protobuf message testgrid.state.UpdateInfo
   741   */
   742  export const UpdateInfo = new UpdateInfo$Type();
   743  // @generated message type with reflection information, may provide speed optimized methods
   744  class AlertInfo$Type extends MessageType<AlertInfo> {
   745      constructor() {
   746          super("testgrid.state.AlertInfo", [
   747              { no: 1, name: "fail_count", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
   748              { no: 2, name: "fail_build_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   749              { no: 3, name: "fail_time", kind: "message", T: () => Timestamp },
   750              { no: 4, name: "fail_test_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   751              { no: 5, name: "pass_build_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   752              { no: 6, name: "pass_time", kind: "message", T: () => Timestamp },
   753              { no: 7, name: "failure_message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   754              { no: 8, name: "build_link", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   755              { no: 9, name: "build_link_text", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   756              { no: 10, name: "build_url_text", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   757              { no: 11, name: "latest_fail_build_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   758              { no: 14, name: "latest_fail_test_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   759              { no: 12, name: "properties", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } },
   760              { no: 13, name: "hotlist_ids", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
   761              { no: 15, name: "email_addresses", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
   762          ]);
   763      }
   764      create(value?: PartialMessage<AlertInfo>): AlertInfo {
   765          const message = { failCount: 0, failBuildId: "", failTestId: "", passBuildId: "", failureMessage: "", buildLink: "", buildLinkText: "", buildUrlText: "", latestFailBuildId: "", latestFailTestId: "", properties: {}, hotlistIds: [], emailAddresses: [] };
   766          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
   767          if (value !== undefined)
   768              reflectionMergePartial<AlertInfo>(this, message, value);
   769          return message;
   770      }
   771      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AlertInfo): AlertInfo {
   772          let message = target ?? this.create(), end = reader.pos + length;
   773          while (reader.pos < end) {
   774              let [fieldNo, wireType] = reader.tag();
   775              switch (fieldNo) {
   776                  case /* int32 fail_count */ 1:
   777                      message.failCount = reader.int32();
   778                      break;
   779                  case /* string fail_build_id */ 2:
   780                      message.failBuildId = reader.string();
   781                      break;
   782                  case /* google.protobuf.Timestamp fail_time */ 3:
   783                      message.failTime = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.failTime);
   784                      break;
   785                  case /* string fail_test_id */ 4:
   786                      message.failTestId = reader.string();
   787                      break;
   788                  case /* string pass_build_id */ 5:
   789                      message.passBuildId = reader.string();
   790                      break;
   791                  case /* google.protobuf.Timestamp pass_time */ 6:
   792                      message.passTime = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.passTime);
   793                      break;
   794                  case /* string failure_message */ 7:
   795                      message.failureMessage = reader.string();
   796                      break;
   797                  case /* string build_link */ 8:
   798                      message.buildLink = reader.string();
   799                      break;
   800                  case /* string build_link_text */ 9:
   801                      message.buildLinkText = reader.string();
   802                      break;
   803                  case /* string build_url_text */ 10:
   804                      message.buildUrlText = reader.string();
   805                      break;
   806                  case /* string latest_fail_build_id */ 11:
   807                      message.latestFailBuildId = reader.string();
   808                      break;
   809                  case /* string latest_fail_test_id */ 14:
   810                      message.latestFailTestId = reader.string();
   811                      break;
   812                  case /* map<string, string> properties */ 12:
   813                      this.binaryReadMap12(message.properties, reader, options);
   814                      break;
   815                  case /* repeated string hotlist_ids */ 13:
   816                      message.hotlistIds.push(reader.string());
   817                      break;
   818                  case /* repeated string email_addresses */ 15:
   819                      message.emailAddresses.push(reader.string());
   820                      break;
   821                  default:
   822                      let u = options.readUnknownField;
   823                      if (u === "throw")
   824                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
   825                      let d = reader.skip(wireType);
   826                      if (u !== false)
   827                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
   828              }
   829          }
   830          return message;
   831      }
   832      private binaryReadMap12(map: AlertInfo["properties"], reader: IBinaryReader, options: BinaryReadOptions): void {
   833          let len = reader.uint32(), end = reader.pos + len, key: keyof AlertInfo["properties"] | undefined, val: AlertInfo["properties"][any] | undefined;
   834          while (reader.pos < end) {
   835              let [fieldNo, wireType] = reader.tag();
   836              switch (fieldNo) {
   837                  case 1:
   838                      key = reader.string();
   839                      break;
   840                  case 2:
   841                      val = reader.string();
   842                      break;
   843                  default: throw new globalThis.Error("unknown map entry field for field testgrid.state.AlertInfo.properties");
   844              }
   845          }
   846          map[key ?? ""] = val ?? "";
   847      }
   848      internalBinaryWrite(message: AlertInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
   849          /* int32 fail_count = 1; */
   850          if (message.failCount !== 0)
   851              writer.tag(1, WireType.Varint).int32(message.failCount);
   852          /* string fail_build_id = 2; */
   853          if (message.failBuildId !== "")
   854              writer.tag(2, WireType.LengthDelimited).string(message.failBuildId);
   855          /* google.protobuf.Timestamp fail_time = 3; */
   856          if (message.failTime)
   857              Timestamp.internalBinaryWrite(message.failTime, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
   858          /* string fail_test_id = 4; */
   859          if (message.failTestId !== "")
   860              writer.tag(4, WireType.LengthDelimited).string(message.failTestId);
   861          /* string pass_build_id = 5; */
   862          if (message.passBuildId !== "")
   863              writer.tag(5, WireType.LengthDelimited).string(message.passBuildId);
   864          /* google.protobuf.Timestamp pass_time = 6; */
   865          if (message.passTime)
   866              Timestamp.internalBinaryWrite(message.passTime, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
   867          /* string failure_message = 7; */
   868          if (message.failureMessage !== "")
   869              writer.tag(7, WireType.LengthDelimited).string(message.failureMessage);
   870          /* string build_link = 8; */
   871          if (message.buildLink !== "")
   872              writer.tag(8, WireType.LengthDelimited).string(message.buildLink);
   873          /* string build_link_text = 9; */
   874          if (message.buildLinkText !== "")
   875              writer.tag(9, WireType.LengthDelimited).string(message.buildLinkText);
   876          /* string build_url_text = 10; */
   877          if (message.buildUrlText !== "")
   878              writer.tag(10, WireType.LengthDelimited).string(message.buildUrlText);
   879          /* string latest_fail_build_id = 11; */
   880          if (message.latestFailBuildId !== "")
   881              writer.tag(11, WireType.LengthDelimited).string(message.latestFailBuildId);
   882          /* string latest_fail_test_id = 14; */
   883          if (message.latestFailTestId !== "")
   884              writer.tag(14, WireType.LengthDelimited).string(message.latestFailTestId);
   885          /* map<string, string> properties = 12; */
   886          for (let k of Object.keys(message.properties))
   887              writer.tag(12, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.properties[k]).join();
   888          /* repeated string hotlist_ids = 13; */
   889          for (let i = 0; i < message.hotlistIds.length; i++)
   890              writer.tag(13, WireType.LengthDelimited).string(message.hotlistIds[i]);
   891          /* repeated string email_addresses = 15; */
   892          for (let i = 0; i < message.emailAddresses.length; i++)
   893              writer.tag(15, WireType.LengthDelimited).string(message.emailAddresses[i]);
   894          let u = options.writeUnknownFields;
   895          if (u !== false)
   896              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
   897          return writer;
   898      }
   899  }
   900  /**
   901   * @generated MessageType for protobuf message testgrid.state.AlertInfo
   902   */
   903  export const AlertInfo = new AlertInfo$Type();
   904  // @generated message type with reflection information, may provide speed optimized methods
   905  class TestMetadata$Type extends MessageType<TestMetadata> {
   906      constructor() {
   907          super("testgrid.state.TestMetadata", [
   908              { no: 1, name: "test_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   909              { no: 2, name: "bug_component", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
   910              { no: 3, name: "owner", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   911              { no: 4, name: "cc", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
   912              { no: 5, name: "error_type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
   913          ]);
   914      }
   915      create(value?: PartialMessage<TestMetadata>): TestMetadata {
   916          const message = { testName: "", bugComponent: 0, owner: "", cc: [], errorType: "" };
   917          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
   918          if (value !== undefined)
   919              reflectionMergePartial<TestMetadata>(this, message, value);
   920          return message;
   921      }
   922      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TestMetadata): TestMetadata {
   923          let message = target ?? this.create(), end = reader.pos + length;
   924          while (reader.pos < end) {
   925              let [fieldNo, wireType] = reader.tag();
   926              switch (fieldNo) {
   927                  case /* string test_name */ 1:
   928                      message.testName = reader.string();
   929                      break;
   930                  case /* int32 bug_component */ 2:
   931                      message.bugComponent = reader.int32();
   932                      break;
   933                  case /* string owner */ 3:
   934                      message.owner = reader.string();
   935                      break;
   936                  case /* repeated string cc */ 4:
   937                      message.cc.push(reader.string());
   938                      break;
   939                  case /* string error_type */ 5:
   940                      message.errorType = reader.string();
   941                      break;
   942                  default:
   943                      let u = options.readUnknownField;
   944                      if (u === "throw")
   945                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
   946                      let d = reader.skip(wireType);
   947                      if (u !== false)
   948                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
   949              }
   950          }
   951          return message;
   952      }
   953      internalBinaryWrite(message: TestMetadata, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
   954          /* string test_name = 1; */
   955          if (message.testName !== "")
   956              writer.tag(1, WireType.LengthDelimited).string(message.testName);
   957          /* int32 bug_component = 2; */
   958          if (message.bugComponent !== 0)
   959              writer.tag(2, WireType.Varint).int32(message.bugComponent);
   960          /* string owner = 3; */
   961          if (message.owner !== "")
   962              writer.tag(3, WireType.LengthDelimited).string(message.owner);
   963          /* repeated string cc = 4; */
   964          for (let i = 0; i < message.cc.length; i++)
   965              writer.tag(4, WireType.LengthDelimited).string(message.cc[i]);
   966          /* string error_type = 5; */
   967          if (message.errorType !== "")
   968              writer.tag(5, WireType.LengthDelimited).string(message.errorType);
   969          let u = options.writeUnknownFields;
   970          if (u !== false)
   971              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
   972          return writer;
   973      }
   974  }
   975  /**
   976   * @generated MessageType for protobuf message testgrid.state.TestMetadata
   977   */
   978  export const TestMetadata = new TestMetadata$Type();
   979  // @generated message type with reflection information, may provide speed optimized methods
   980  class Column$Type extends MessageType<Column> {
   981      constructor() {
   982          super("testgrid.state.Column", [
   983              { no: 1, name: "build", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   984              { no: 2, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   985              { no: 3, name: "started", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
   986              { no: 4, name: "extra", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
   987              { no: 5, name: "hotlist_ids", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   988              { no: 6, name: "hint", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
   989              { no: 7, name: "email_addresses", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
   990              { no: 8, name: "stats", kind: "message", T: () => Stats }
   991          ]);
   992      }
   993      create(value?: PartialMessage<Column>): Column {
   994          const message = { build: "", name: "", started: 0, extra: [], hotlistIds: "", hint: "", emailAddresses: [] };
   995          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
   996          if (value !== undefined)
   997              reflectionMergePartial<Column>(this, message, value);
   998          return message;
   999      }
  1000      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Column): Column {
  1001          let message = target ?? this.create(), end = reader.pos + length;
  1002          while (reader.pos < end) {
  1003              let [fieldNo, wireType] = reader.tag();
  1004              switch (fieldNo) {
  1005                  case /* string build */ 1:
  1006                      message.build = reader.string();
  1007                      break;
  1008                  case /* string name */ 2:
  1009                      message.name = reader.string();
  1010                      break;
  1011                  case /* double started */ 3:
  1012                      message.started = reader.double();
  1013                      break;
  1014                  case /* repeated string extra */ 4:
  1015                      message.extra.push(reader.string());
  1016                      break;
  1017                  case /* string hotlist_ids */ 5:
  1018                      message.hotlistIds = reader.string();
  1019                      break;
  1020                  case /* string hint */ 6:
  1021                      message.hint = reader.string();
  1022                      break;
  1023                  case /* repeated string email_addresses */ 7:
  1024                      message.emailAddresses.push(reader.string());
  1025                      break;
  1026                  case /* testgrid.state.Stats stats */ 8:
  1027                      message.stats = Stats.internalBinaryRead(reader, reader.uint32(), options, message.stats);
  1028                      break;
  1029                  default:
  1030                      let u = options.readUnknownField;
  1031                      if (u === "throw")
  1032                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  1033                      let d = reader.skip(wireType);
  1034                      if (u !== false)
  1035                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  1036              }
  1037          }
  1038          return message;
  1039      }
  1040      internalBinaryWrite(message: Column, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
  1041          /* string build = 1; */
  1042          if (message.build !== "")
  1043              writer.tag(1, WireType.LengthDelimited).string(message.build);
  1044          /* string name = 2; */
  1045          if (message.name !== "")
  1046              writer.tag(2, WireType.LengthDelimited).string(message.name);
  1047          /* double started = 3; */
  1048          if (message.started !== 0)
  1049              writer.tag(3, WireType.Bit64).double(message.started);
  1050          /* repeated string extra = 4; */
  1051          for (let i = 0; i < message.extra.length; i++)
  1052              writer.tag(4, WireType.LengthDelimited).string(message.extra[i]);
  1053          /* string hotlist_ids = 5; */
  1054          if (message.hotlistIds !== "")
  1055              writer.tag(5, WireType.LengthDelimited).string(message.hotlistIds);
  1056          /* string hint = 6; */
  1057          if (message.hint !== "")
  1058              writer.tag(6, WireType.LengthDelimited).string(message.hint);
  1059          /* repeated string email_addresses = 7; */
  1060          for (let i = 0; i < message.emailAddresses.length; i++)
  1061              writer.tag(7, WireType.LengthDelimited).string(message.emailAddresses[i]);
  1062          /* testgrid.state.Stats stats = 8; */
  1063          if (message.stats)
  1064              Stats.internalBinaryWrite(message.stats, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
  1065          let u = options.writeUnknownFields;
  1066          if (u !== false)
  1067              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  1068          return writer;
  1069      }
  1070  }
  1071  /**
  1072   * @generated MessageType for protobuf message testgrid.state.Column
  1073   */
  1074  export const Column = new Column$Type();
  1075  // @generated message type with reflection information, may provide speed optimized methods
  1076  class Stats$Type extends MessageType<Stats> {
  1077      constructor() {
  1078          super("testgrid.state.Stats", [
  1079              { no: 1, name: "fail_count", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
  1080              { no: 2, name: "pass_count", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
  1081              { no: 3, name: "total_count", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
  1082              { no: 4, name: "pending", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
  1083              { no: 5, name: "broken", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
  1084          ]);
  1085      }
  1086      create(value?: PartialMessage<Stats>): Stats {
  1087          const message = { failCount: 0, passCount: 0, totalCount: 0, pending: false, broken: false };
  1088          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
  1089          if (value !== undefined)
  1090              reflectionMergePartial<Stats>(this, message, value);
  1091          return message;
  1092      }
  1093      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Stats): Stats {
  1094          let message = target ?? this.create(), end = reader.pos + length;
  1095          while (reader.pos < end) {
  1096              let [fieldNo, wireType] = reader.tag();
  1097              switch (fieldNo) {
  1098                  case /* int32 fail_count */ 1:
  1099                      message.failCount = reader.int32();
  1100                      break;
  1101                  case /* int32 pass_count */ 2:
  1102                      message.passCount = reader.int32();
  1103                      break;
  1104                  case /* int32 total_count */ 3:
  1105                      message.totalCount = reader.int32();
  1106                      break;
  1107                  case /* bool pending */ 4:
  1108                      message.pending = reader.bool();
  1109                      break;
  1110                  case /* bool broken */ 5:
  1111                      message.broken = reader.bool();
  1112                      break;
  1113                  default:
  1114                      let u = options.readUnknownField;
  1115                      if (u === "throw")
  1116                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  1117                      let d = reader.skip(wireType);
  1118                      if (u !== false)
  1119                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  1120              }
  1121          }
  1122          return message;
  1123      }
  1124      internalBinaryWrite(message: Stats, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
  1125          /* int32 fail_count = 1; */
  1126          if (message.failCount !== 0)
  1127              writer.tag(1, WireType.Varint).int32(message.failCount);
  1128          /* int32 pass_count = 2; */
  1129          if (message.passCount !== 0)
  1130              writer.tag(2, WireType.Varint).int32(message.passCount);
  1131          /* int32 total_count = 3; */
  1132          if (message.totalCount !== 0)
  1133              writer.tag(3, WireType.Varint).int32(message.totalCount);
  1134          /* bool pending = 4; */
  1135          if (message.pending !== false)
  1136              writer.tag(4, WireType.Varint).bool(message.pending);
  1137          /* bool broken = 5; */
  1138          if (message.broken !== false)
  1139              writer.tag(5, WireType.Varint).bool(message.broken);
  1140          let u = options.writeUnknownFields;
  1141          if (u !== false)
  1142              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  1143          return writer;
  1144      }
  1145  }
  1146  /**
  1147   * @generated MessageType for protobuf message testgrid.state.Stats
  1148   */
  1149  export const Stats = new Stats$Type();
  1150  // @generated message type with reflection information, may provide speed optimized methods
  1151  class Row$Type extends MessageType<Row> {
  1152      constructor() {
  1153          super("testgrid.state.Row", [
  1154              { no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
  1155              { no: 2, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
  1156              { no: 3, name: "results", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 5 /*ScalarType.INT32*/ },
  1157              { no: 4, name: "cell_ids", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
  1158              { no: 5, name: "messages", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
  1159              { no: 7, name: "metric", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
  1160              { no: 8, name: "metrics", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Metric },
  1161              { no: 9, name: "icons", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
  1162              { no: 10, name: "issues", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
  1163              { no: 11, name: "alert_info", kind: "message", T: () => AlertInfo },
  1164              { no: 12, name: "user_property", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
  1165              { no: 13, name: "properties", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Property }
  1166          ]);
  1167      }
  1168      create(value?: PartialMessage<Row>): Row {
  1169          const message = { name: "", id: "", results: [], cellIds: [], messages: [], metric: [], metrics: [], icons: [], issues: [], userProperty: [], properties: [] };
  1170          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
  1171          if (value !== undefined)
  1172              reflectionMergePartial<Row>(this, message, value);
  1173          return message;
  1174      }
  1175      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Row): Row {
  1176          let message = target ?? this.create(), end = reader.pos + length;
  1177          while (reader.pos < end) {
  1178              let [fieldNo, wireType] = reader.tag();
  1179              switch (fieldNo) {
  1180                  case /* string name */ 1:
  1181                      message.name = reader.string();
  1182                      break;
  1183                  case /* string id */ 2:
  1184                      message.id = reader.string();
  1185                      break;
  1186                  case /* repeated int32 results */ 3:
  1187                      if (wireType === WireType.LengthDelimited)
  1188                          for (let e = reader.int32() + reader.pos; reader.pos < e;)
  1189                              message.results.push(reader.int32());
  1190                      else
  1191                          message.results.push(reader.int32());
  1192                      break;
  1193                  case /* repeated string cell_ids */ 4:
  1194                      message.cellIds.push(reader.string());
  1195                      break;
  1196                  case /* repeated string messages */ 5:
  1197                      message.messages.push(reader.string());
  1198                      break;
  1199                  case /* repeated string metric */ 7:
  1200                      message.metric.push(reader.string());
  1201                      break;
  1202                  case /* repeated testgrid.state.Metric metrics */ 8:
  1203                      message.metrics.push(Metric.internalBinaryRead(reader, reader.uint32(), options));
  1204                      break;
  1205                  case /* repeated string icons */ 9:
  1206                      message.icons.push(reader.string());
  1207                      break;
  1208                  case /* repeated string issues */ 10:
  1209                      message.issues.push(reader.string());
  1210                      break;
  1211                  case /* testgrid.state.AlertInfo alert_info */ 11:
  1212                      message.alertInfo = AlertInfo.internalBinaryRead(reader, reader.uint32(), options, message.alertInfo);
  1213                      break;
  1214                  case /* repeated string user_property */ 12:
  1215                      message.userProperty.push(reader.string());
  1216                      break;
  1217                  case /* repeated testgrid.state.Property properties */ 13:
  1218                      message.properties.push(Property.internalBinaryRead(reader, reader.uint32(), options));
  1219                      break;
  1220                  default:
  1221                      let u = options.readUnknownField;
  1222                      if (u === "throw")
  1223                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  1224                      let d = reader.skip(wireType);
  1225                      if (u !== false)
  1226                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  1227              }
  1228          }
  1229          return message;
  1230      }
  1231      internalBinaryWrite(message: Row, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
  1232          /* string name = 1; */
  1233          if (message.name !== "")
  1234              writer.tag(1, WireType.LengthDelimited).string(message.name);
  1235          /* string id = 2; */
  1236          if (message.id !== "")
  1237              writer.tag(2, WireType.LengthDelimited).string(message.id);
  1238          /* repeated int32 results = 3; */
  1239          if (message.results.length) {
  1240              writer.tag(3, WireType.LengthDelimited).fork();
  1241              for (let i = 0; i < message.results.length; i++)
  1242                  writer.int32(message.results[i]);
  1243              writer.join();
  1244          }
  1245          /* repeated string cell_ids = 4; */
  1246          for (let i = 0; i < message.cellIds.length; i++)
  1247              writer.tag(4, WireType.LengthDelimited).string(message.cellIds[i]);
  1248          /* repeated string messages = 5; */
  1249          for (let i = 0; i < message.messages.length; i++)
  1250              writer.tag(5, WireType.LengthDelimited).string(message.messages[i]);
  1251          /* repeated string metric = 7; */
  1252          for (let i = 0; i < message.metric.length; i++)
  1253              writer.tag(7, WireType.LengthDelimited).string(message.metric[i]);
  1254          /* repeated testgrid.state.Metric metrics = 8; */
  1255          for (let i = 0; i < message.metrics.length; i++)
  1256              Metric.internalBinaryWrite(message.metrics[i], writer.tag(8, WireType.LengthDelimited).fork(), options).join();
  1257          /* repeated string icons = 9; */
  1258          for (let i = 0; i < message.icons.length; i++)
  1259              writer.tag(9, WireType.LengthDelimited).string(message.icons[i]);
  1260          /* repeated string issues = 10; */
  1261          for (let i = 0; i < message.issues.length; i++)
  1262              writer.tag(10, WireType.LengthDelimited).string(message.issues[i]);
  1263          /* testgrid.state.AlertInfo alert_info = 11; */
  1264          if (message.alertInfo)
  1265              AlertInfo.internalBinaryWrite(message.alertInfo, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
  1266          /* repeated string user_property = 12; */
  1267          for (let i = 0; i < message.userProperty.length; i++)
  1268              writer.tag(12, WireType.LengthDelimited).string(message.userProperty[i]);
  1269          /* repeated testgrid.state.Property properties = 13; */
  1270          for (let i = 0; i < message.properties.length; i++)
  1271              Property.internalBinaryWrite(message.properties[i], writer.tag(13, WireType.LengthDelimited).fork(), options).join();
  1272          let u = options.writeUnknownFields;
  1273          if (u !== false)
  1274              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  1275          return writer;
  1276      }
  1277  }
  1278  /**
  1279   * @generated MessageType for protobuf message testgrid.state.Row
  1280   */
  1281  export const Row = new Row$Type();
  1282  // @generated message type with reflection information, may provide speed optimized methods
  1283  class Grid$Type extends MessageType<Grid> {
  1284      constructor() {
  1285          super("testgrid.state.Grid", [
  1286              { no: 1, name: "columns", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Column },
  1287              { no: 2, name: "rows", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Row },
  1288              { no: 4, name: "config", kind: "message", T: () => TestGroup },
  1289              { no: 6, name: "last_time_updated", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ },
  1290              { no: 8, name: "update_info", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => UpdateInfo },
  1291              { no: 9, name: "test_metadata", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => TestMetadata },
  1292              { no: 10, name: "cluster", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Cluster },
  1293              { no: 11, name: "most_recent_cluster_timestamp", kind: "scalar", T: 1 /*ScalarType.DOUBLE*/ }
  1294          ]);
  1295      }
  1296      create(value?: PartialMessage<Grid>): Grid {
  1297          const message = { columns: [], rows: [], lastTimeUpdated: 0, updateInfo: [], testMetadata: [], cluster: [], mostRecentClusterTimestamp: 0 };
  1298          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
  1299          if (value !== undefined)
  1300              reflectionMergePartial<Grid>(this, message, value);
  1301          return message;
  1302      }
  1303      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Grid): Grid {
  1304          let message = target ?? this.create(), end = reader.pos + length;
  1305          while (reader.pos < end) {
  1306              let [fieldNo, wireType] = reader.tag();
  1307              switch (fieldNo) {
  1308                  case /* repeated testgrid.state.Column columns */ 1:
  1309                      message.columns.push(Column.internalBinaryRead(reader, reader.uint32(), options));
  1310                      break;
  1311                  case /* repeated testgrid.state.Row rows */ 2:
  1312                      message.rows.push(Row.internalBinaryRead(reader, reader.uint32(), options));
  1313                      break;
  1314                  case /* testgrid.config.TestGroup config */ 4:
  1315                      message.config = TestGroup.internalBinaryRead(reader, reader.uint32(), options, message.config);
  1316                      break;
  1317                  case /* double last_time_updated */ 6:
  1318                      message.lastTimeUpdated = reader.double();
  1319                      break;
  1320                  case /* repeated testgrid.state.UpdateInfo update_info */ 8:
  1321                      message.updateInfo.push(UpdateInfo.internalBinaryRead(reader, reader.uint32(), options));
  1322                      break;
  1323                  case /* repeated testgrid.state.TestMetadata test_metadata */ 9:
  1324                      message.testMetadata.push(TestMetadata.internalBinaryRead(reader, reader.uint32(), options));
  1325                      break;
  1326                  case /* repeated testgrid.state.Cluster cluster */ 10:
  1327                      message.cluster.push(Cluster.internalBinaryRead(reader, reader.uint32(), options));
  1328                      break;
  1329                  case /* double most_recent_cluster_timestamp */ 11:
  1330                      message.mostRecentClusterTimestamp = reader.double();
  1331                      break;
  1332                  default:
  1333                      let u = options.readUnknownField;
  1334                      if (u === "throw")
  1335                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  1336                      let d = reader.skip(wireType);
  1337                      if (u !== false)
  1338                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  1339              }
  1340          }
  1341          return message;
  1342      }
  1343      internalBinaryWrite(message: Grid, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
  1344          /* repeated testgrid.state.Column columns = 1; */
  1345          for (let i = 0; i < message.columns.length; i++)
  1346              Column.internalBinaryWrite(message.columns[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
  1347          /* repeated testgrid.state.Row rows = 2; */
  1348          for (let i = 0; i < message.rows.length; i++)
  1349              Row.internalBinaryWrite(message.rows[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
  1350          /* testgrid.config.TestGroup config = 4; */
  1351          if (message.config)
  1352              TestGroup.internalBinaryWrite(message.config, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
  1353          /* double last_time_updated = 6; */
  1354          if (message.lastTimeUpdated !== 0)
  1355              writer.tag(6, WireType.Bit64).double(message.lastTimeUpdated);
  1356          /* repeated testgrid.state.UpdateInfo update_info = 8; */
  1357          for (let i = 0; i < message.updateInfo.length; i++)
  1358              UpdateInfo.internalBinaryWrite(message.updateInfo[i], writer.tag(8, WireType.LengthDelimited).fork(), options).join();
  1359          /* repeated testgrid.state.TestMetadata test_metadata = 9; */
  1360          for (let i = 0; i < message.testMetadata.length; i++)
  1361              TestMetadata.internalBinaryWrite(message.testMetadata[i], writer.tag(9, WireType.LengthDelimited).fork(), options).join();
  1362          /* repeated testgrid.state.Cluster cluster = 10; */
  1363          for (let i = 0; i < message.cluster.length; i++)
  1364              Cluster.internalBinaryWrite(message.cluster[i], writer.tag(10, WireType.LengthDelimited).fork(), options).join();
  1365          /* double most_recent_cluster_timestamp = 11; */
  1366          if (message.mostRecentClusterTimestamp !== 0)
  1367              writer.tag(11, WireType.Bit64).double(message.mostRecentClusterTimestamp);
  1368          let u = options.writeUnknownFields;
  1369          if (u !== false)
  1370              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  1371          return writer;
  1372      }
  1373  }
  1374  /**
  1375   * @generated MessageType for protobuf message testgrid.state.Grid
  1376   */
  1377  export const Grid = new Grid$Type();
  1378  // @generated message type with reflection information, may provide speed optimized methods
  1379  class Cluster$Type extends MessageType<Cluster> {
  1380      constructor() {
  1381          super("testgrid.state.Cluster", [
  1382              { no: 1, name: "test_status", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
  1383              { no: 2, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
  1384              { no: 3, name: "cluster_row", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => ClusterRow }
  1385          ]);
  1386      }
  1387      create(value?: PartialMessage<Cluster>): Cluster {
  1388          const message = { testStatus: 0, message: "", clusterRow: [] };
  1389          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
  1390          if (value !== undefined)
  1391              reflectionMergePartial<Cluster>(this, message, value);
  1392          return message;
  1393      }
  1394      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Cluster): Cluster {
  1395          let message = target ?? this.create(), end = reader.pos + length;
  1396          while (reader.pos < end) {
  1397              let [fieldNo, wireType] = reader.tag();
  1398              switch (fieldNo) {
  1399                  case /* int32 test_status */ 1:
  1400                      message.testStatus = reader.int32();
  1401                      break;
  1402                  case /* string message */ 2:
  1403                      message.message = reader.string();
  1404                      break;
  1405                  case /* repeated testgrid.state.ClusterRow cluster_row */ 3:
  1406                      message.clusterRow.push(ClusterRow.internalBinaryRead(reader, reader.uint32(), options));
  1407                      break;
  1408                  default:
  1409                      let u = options.readUnknownField;
  1410                      if (u === "throw")
  1411                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  1412                      let d = reader.skip(wireType);
  1413                      if (u !== false)
  1414                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  1415              }
  1416          }
  1417          return message;
  1418      }
  1419      internalBinaryWrite(message: Cluster, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
  1420          /* int32 test_status = 1; */
  1421          if (message.testStatus !== 0)
  1422              writer.tag(1, WireType.Varint).int32(message.testStatus);
  1423          /* string message = 2; */
  1424          if (message.message !== "")
  1425              writer.tag(2, WireType.LengthDelimited).string(message.message);
  1426          /* repeated testgrid.state.ClusterRow cluster_row = 3; */
  1427          for (let i = 0; i < message.clusterRow.length; i++)
  1428              ClusterRow.internalBinaryWrite(message.clusterRow[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
  1429          let u = options.writeUnknownFields;
  1430          if (u !== false)
  1431              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  1432          return writer;
  1433      }
  1434  }
  1435  /**
  1436   * @generated MessageType for protobuf message testgrid.state.Cluster
  1437   */
  1438  export const Cluster = new Cluster$Type();
  1439  // @generated message type with reflection information, may provide speed optimized methods
  1440  class ClusterRow$Type extends MessageType<ClusterRow> {
  1441      constructor() {
  1442          super("testgrid.state.ClusterRow", [
  1443              { no: 1, name: "display_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
  1444              { no: 2, name: "index", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 5 /*ScalarType.INT32*/ }
  1445          ]);
  1446      }
  1447      create(value?: PartialMessage<ClusterRow>): ClusterRow {
  1448          const message = { displayName: "", index: [] };
  1449          globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
  1450          if (value !== undefined)
  1451              reflectionMergePartial<ClusterRow>(this, message, value);
  1452          return message;
  1453      }
  1454      internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ClusterRow): ClusterRow {
  1455          let message = target ?? this.create(), end = reader.pos + length;
  1456          while (reader.pos < end) {
  1457              let [fieldNo, wireType] = reader.tag();
  1458              switch (fieldNo) {
  1459                  case /* string display_name */ 1:
  1460                      message.displayName = reader.string();
  1461                      break;
  1462                  case /* repeated int32 index */ 2:
  1463                      if (wireType === WireType.LengthDelimited)
  1464                          for (let e = reader.int32() + reader.pos; reader.pos < e;)
  1465                              message.index.push(reader.int32());
  1466                      else
  1467                          message.index.push(reader.int32());
  1468                      break;
  1469                  default:
  1470                      let u = options.readUnknownField;
  1471                      if (u === "throw")
  1472                          throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
  1473                      let d = reader.skip(wireType);
  1474                      if (u !== false)
  1475                          (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
  1476              }
  1477          }
  1478          return message;
  1479      }
  1480      internalBinaryWrite(message: ClusterRow, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
  1481          /* string display_name = 1; */
  1482          if (message.displayName !== "")
  1483              writer.tag(1, WireType.LengthDelimited).string(message.displayName);
  1484          /* repeated int32 index = 2; */
  1485          if (message.index.length) {
  1486              writer.tag(2, WireType.LengthDelimited).fork();
  1487              for (let i = 0; i < message.index.length; i++)
  1488                  writer.int32(message.index[i]);
  1489              writer.join();
  1490          }
  1491          let u = options.writeUnknownFields;
  1492          if (u !== false)
  1493              (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
  1494          return writer;
  1495      }
  1496  }
  1497  /**
  1498   * @generated MessageType for protobuf message testgrid.state.ClusterRow
  1499   */
  1500  export const ClusterRow = new ClusterRow$Type();