// @generated by protoc-gen-es v1.10.1 with parameter "target=ts"
// @generated from file preflight/v2/preflight.proto (package preflight.v2, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, protoInt64 } from "@bufbuild/protobuf";
import { ObjectRef } from "../../common/v1/object-ref_pb.js";

/**
 * @generated from enum preflight.v2.ReportState
 */
export enum ReportState {
  /**
   * It's good practice to have an unspecified or default value of 0
   *
   * @generated from enum value: REPORT_STATE_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: REPORT_STATE_PROCESSING = 2;
   */
  PROCESSING = 2,

  /**
   * @generated from enum value: REPORT_STATE_FAILED = 3;
   */
  FAILED = 3,
}
// Retrieve enum metadata with: proto3.getEnumType(ReportState)
proto3.util.setEnumType(ReportState, "preflight.v2.ReportState", [
  { no: 0, name: "REPORT_STATE_UNSPECIFIED" },
  { no: 1, name: "REPORT_STATE_COMPLETE" },
  { no: 2, name: "REPORT_STATE_PROCESSING" },
  { no: 3, name: "REPORT_STATE_FAILED" },
]);

/**
 * @generated from message preflight.v2.PreflightFileReport
 */
export class PreflightFileReport extends Message<PreflightFileReport> {
  /**
   * @generated from field: string object_id = 1;
   */
  objectId = "";

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

  /**
   * @generated from field: int64 artworker_id = 3;
   */
  artworkerId = protoInt64.zero;

  /**
   * @generated from field: int64 media_item_id = 4;
   */
  mediaItemId = protoInt64.zero;

  /**
   * @generated from field: int64 task_execution_plan_id = 5;
   */
  taskExecutionPlanId = protoInt64.zero;

  /**
   * @generated from field: int32 file_num = 6;
   */
  fileNum = 0;

  /**
   * @generated from field: int32 file_size = 7;
   */
  fileSize = 0;

  /**
   * @generated from field: preflight.v2.DocumentCheck report = 8;
   */
  report?: DocumentCheck;

  /**
   * @generated from field: preflight.v2.ReportState state = 9;
   */
  state = ReportState.UNSPECIFIED;

  /**
   * @generated from field: string error = 10;
   */
  error = "";

  /**
   * @generated from field: string error_code = 11;
   */
  errorCode = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.PreflightFileReport";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "object_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "object_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "artworker_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 4, name: "media_item_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 5, name: "task_execution_plan_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 6, name: "file_num", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 7, name: "file_size", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 8, name: "report", kind: "message", T: DocumentCheck },
    { no: 9, name: "state", kind: "enum", T: proto3.getEnumType(ReportState) },
    { no: 10, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 11, name: "error_code", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.PreflightPageReport
 */
export class PreflightPageReport extends Message<PreflightPageReport> {
  /**
   * @generated from field: string object_id = 1;
   */
  objectId = "";

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

  /**
   * @generated from field: int64 artworker_id = 3;
   */
  artworkerId = protoInt64.zero;

  /**
   * @generated from field: int64 media_item_id = 4;
   */
  mediaItemId = protoInt64.zero;

  /**
   * @generated from field: int64 task_execution_plan_id = 5;
   */
  taskExecutionPlanId = protoInt64.zero;

  /**
   * @generated from field: int32 file_num = 6;
   */
  fileNum = 0;

  /**
   * @generated from field: int32 page = 7;
   */
  page = 0;

  /**
   * @generated from field: int32 file_size = 8;
   */
  fileSize = 0;

  /**
   * @generated from field: preflight.v2.DocumentCheck report = 9;
   */
  report?: DocumentCheck;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.PreflightPageReport";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "object_id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "object_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "artworker_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 4, name: "media_item_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 5, name: "task_execution_plan_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 6, name: "file_num", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 7, name: "page", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 8, name: "file_size", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 9, name: "report", kind: "message", T: DocumentCheck },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.DocumentCheck
 */
export class DocumentCheck extends Message<DocumentCheck> {
  /**
   * @generated from field: preflight.v2.DocumentCheck.Checks checks = 1;
   */
  checks?: DocumentCheck_Checks;

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 3;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 4;
   */
  warnings?: Warnings;

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

  /**
   * @generated from field: optional preflight.v2.DocumentInfo document_info = 6;
   */
  documentInfo?: DocumentInfo;

  /**
   * @generated from field: optional string error = 7;
   */
  error?: string;

  /**
   * @generated from field: int32 error_code = 8;
   */
  errorCode = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.DocumentCheck";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "checks", kind: "message", T: DocumentCheck_Checks },
    { no: 2, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 4, name: "warnings", kind: "message", T: Warnings, opt: true },
    { no: 5, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 6, name: "document_info", kind: "message", T: DocumentInfo, opt: true },
    { no: 7, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 8, name: "error_code", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.DocumentCheck.Checks
 */
export class DocumentCheck_Checks extends Message<DocumentCheck_Checks> {
  /**
   * @generated from field: preflight.v2.ColourChecks colours = 1;
   */
  colours?: ColourChecks;

  /**
   * @generated from field: preflight.v2.DimensionsChecks dimensions = 2;
   */
  dimensions?: DimensionsChecks;

  /**
   * @generated from field: preflight.v2.FontChecks fonts = 3;
   */
  fonts?: FontChecks;

  /**
   * @generated from field: preflight.v2.ImageChecks images = 4;
   */
  images?: ImageChecks;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.DocumentCheck.Checks";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "colours", kind: "message", T: ColourChecks },
    { no: 2, name: "dimensions", kind: "message", T: DimensionsChecks },
    { no: 3, name: "fonts", kind: "message", T: FontChecks },
    { no: 4, name: "images", kind: "message", T: ImageChecks },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.DocumentInfo
 */
export class DocumentInfo extends Message<DocumentInfo> {
  /**
   * @generated from field: int32 page_count = 1;
   */
  pageCount = 0;

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

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

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

  /**
   * @generated from field: repeated preflight.v2.DocumentInfo.OutputIntent output_intents = 5;
   */
  outputIntents: DocumentInfo_OutputIntent[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.DocumentInfo";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "page_count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 2, name: "created_at", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "modified_at", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "creator", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "output_intents", kind: "message", T: DocumentInfo_OutputIntent, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.DocumentInfo.OutputIntent
 */
export class DocumentInfo_OutputIntent extends Message<DocumentInfo_OutputIntent> {
  /**
   * @generated from field: string info = 1;
   */
  info = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.DocumentInfo.OutputIntent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "info", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * -----------------------------------------------------------------------
 *  Each group has explicit checks: no "map<string, Check> needed.
 * -----------------------------------------------------------------------
 *
 * @generated from message preflight.v2.ColourChecks
 */
export class ColourChecks extends Message<ColourChecks> {
  /**
   * @generated from field: preflight.v2.ColourChecks.Checks checks = 1;
   */
  checks?: ColourChecks_Checks;

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 3;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 4;
   */
  warnings?: Warnings;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ColourChecks";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "checks", kind: "message", T: ColourChecks_Checks },
    { no: 2, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 4, name: "warnings", kind: "message", T: Warnings, opt: true },
    { no: 5, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

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

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

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

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

/**
 * The single "checkColours" as a specialized message:
 *
 * @generated from message preflight.v2.ColourChecks.Checks
 */
export class ColourChecks_Checks extends Message<ColourChecks_Checks> {
  /**
   * @generated from field: preflight.v2.ColourCheck check_colours = 1;
   */
  checkColours?: ColourCheck;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ColourChecks.Checks";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "check_colours", kind: "message", T: ColourCheck },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.DimensionsChecks
 */
export class DimensionsChecks extends Message<DimensionsChecks> {
  /**
   * @generated from field: preflight.v2.DimensionsChecks.Checks checks = 1;
   */
  checks?: DimensionsChecks_Checks;

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 3;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 4;
   */
  warnings?: Warnings;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.DimensionsChecks";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "checks", kind: "message", T: DimensionsChecks_Checks },
    { no: 2, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 4, name: "warnings", kind: "message", T: Warnings, opt: true },
    { no: 5, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.DimensionsChecks.Checks
 */
export class DimensionsChecks_Checks extends Message<DimensionsChecks_Checks> {
  /**
   * @generated from field: preflight.v2.AspectRatioCheck aspect_ratio = 1;
   */
  aspectRatio?: AspectRatioCheck;

  /**
   * @generated from field: preflight.v2.BleedCheck bleed = 2;
   */
  bleed?: BleedCheck;

  /**
   * @generated from field: preflight.v2.OrientationCheck orientation = 3;
   */
  orientation?: OrientationCheck;

  /**
   * @generated from field: preflight.v2.TrimSizeCheck trim_size = 4;
   */
  trimSize?: TrimSizeCheck;

  /**
   * @generated from field: preflight.v2.BoxSizeCheck media_box_size = 5;
   */
  mediaBoxSize?: BoxSizeCheck;

  /**
   * @generated from field: preflight.v2.BoxSizeCheck bleed_box_size = 6;
   */
  bleedBoxSize?: BoxSizeCheck;

  /**
   * @generated from field: preflight.v2.BoxSizeCheck art_box_size = 7;
   */
  artBoxSize?: BoxSizeCheck;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.DimensionsChecks.Checks";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "aspect_ratio", kind: "message", T: AspectRatioCheck },
    { no: 2, name: "bleed", kind: "message", T: BleedCheck },
    { no: 3, name: "orientation", kind: "message", T: OrientationCheck },
    { no: 4, name: "trim_size", kind: "message", T: TrimSizeCheck },
    { no: 5, name: "media_box_size", kind: "message", T: BoxSizeCheck },
    { no: 6, name: "bleed_box_size", kind: "message", T: BoxSizeCheck },
    { no: 7, name: "art_box_size", kind: "message", T: BoxSizeCheck },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.FontChecks
 */
export class FontChecks extends Message<FontChecks> {
  /**
   * @generated from field: preflight.v2.FontChecks.Checks checks = 1;
   */
  checks?: FontChecks_Checks;

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 3;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 4;
   */
  warnings?: Warnings;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.FontChecks";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "checks", kind: "message", T: FontChecks_Checks },
    { no: 2, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 4, name: "warnings", kind: "message", T: Warnings, opt: true },
    { no: 5, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.FontChecks.Checks
 */
export class FontChecks_Checks extends Message<FontChecks_Checks> {
  /**
   * @generated from field: preflight.v2.FontsEmbeddedCheck fonts_embedded = 1;
   */
  fontsEmbedded?: FontsEmbeddedCheck;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.FontChecks.Checks";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "fonts_embedded", kind: "message", T: FontsEmbeddedCheck },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ImageChecks
 */
export class ImageChecks extends Message<ImageChecks> {
  /**
   * @generated from field: preflight.v2.ImageChecks.Checks checks = 1;
   */
  checks?: ImageChecks_Checks;

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 3;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 4;
   */
  warnings?: Warnings;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ImageChecks";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "checks", kind: "message", T: ImageChecks_Checks },
    { no: 2, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 4, name: "warnings", kind: "message", T: Warnings, opt: true },
    { no: 5, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ImageChecks.Checks
 */
export class ImageChecks_Checks extends Message<ImageChecks_Checks> {
  /**
   * @generated from field: preflight.v2.ImageResolutionCheck image_resolution = 1;
   */
  imageResolution?: ImageResolutionCheck;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ImageChecks.Checks";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "image_resolution", kind: "message", T: ImageResolutionCheck },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ColourCheck
 */
export class ColourCheck extends Message<ColourCheck> {
  /**
   * @generated from field: bool check_enabled = 1;
   */
  checkEnabled = false;

  /**
   * @generated from field: preflight.v2.ColourCheckInput input = 2;
   */
  input?: ColourCheckInput;

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

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

  /**
   * @generated from field: preflight.v2.ColourCheckOutput output = 5;
   */
  output?: ColourCheckOutput;

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

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 8;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 9;
   */
  warnings?: Warnings;

  /**
   * @generated from field: optional preflight.v2.ColourPageDifferenceSummary page_difference_summary = 10;
   */
  pageDifferenceSummary?: ColourPageDifferenceSummary;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ColourCheck";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "check_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "input", kind: "message", T: ColourCheckInput },
    { no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "output", kind: "message", T: ColourCheckOutput },
    { no: 6, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "summary", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 9, name: "warnings", kind: "message", T: Warnings, opt: true },
    { no: 10, name: "page_difference_summary", kind: "message", T: ColourPageDifferenceSummary, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.AspectRatioCheck
 */
export class AspectRatioCheck extends Message<AspectRatioCheck> {
  /**
   * @generated from field: bool check_enabled = 1;
   */
  checkEnabled = false;

  /**
   * @generated from field: preflight.v2.AspectRatioCheckInput input = 2;
   */
  input?: AspectRatioCheckInput;

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

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

  /**
   * @generated from field: preflight.v2.AspectRatioCheckOutput output = 5;
   */
  output?: AspectRatioCheckOutput;

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

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 8;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 9;
   */
  warnings?: Warnings;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.AspectRatioCheck";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "check_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "input", kind: "message", T: AspectRatioCheckInput },
    { no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "output", kind: "message", T: AspectRatioCheckOutput },
    { no: 6, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "summary", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 9, name: "warnings", kind: "message", T: Warnings, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.BleedCheck
 */
export class BleedCheck extends Message<BleedCheck> {
  /**
   * @generated from field: bool check_enabled = 1;
   */
  checkEnabled = false;

  /**
   * @generated from field: preflight.v2.BleedCheckInput input = 2;
   */
  input?: BleedCheckInput;

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

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

  /**
   * @generated from field: preflight.v2.BleedCheckOutput output = 5;
   */
  output?: BleedCheckOutput;

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

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 8;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 9;
   */
  warnings?: Warnings;

  /**
   * @generated from field: optional preflight.v2.BleedPageDifferenceSummary page_difference_summary = 10;
   */
  pageDifferenceSummary?: BleedPageDifferenceSummary;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.BleedCheck";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "check_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "input", kind: "message", T: BleedCheckInput },
    { no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "output", kind: "message", T: BleedCheckOutput },
    { no: 6, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "summary", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 9, name: "warnings", kind: "message", T: Warnings, opt: true },
    { no: 10, name: "page_difference_summary", kind: "message", T: BleedPageDifferenceSummary, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.OrientationCheck
 */
export class OrientationCheck extends Message<OrientationCheck> {
  /**
   * @generated from field: bool check_enabled = 1;
   */
  checkEnabled = false;

  /**
   * @generated from field: preflight.v2.OrientationCheckInput input = 2;
   */
  input?: OrientationCheckInput;

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

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

  /**
   * @generated from field: preflight.v2.OrientationCheckOutput output = 5;
   */
  output?: OrientationCheckOutput;

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

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 8;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 9;
   */
  warnings?: Warnings;

  /**
   * @generated from field: optional preflight.v2.OrientationPageDifferenceSummary page_difference_summary = 10;
   */
  pageDifferenceSummary?: OrientationPageDifferenceSummary;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.OrientationCheck";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "check_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "input", kind: "message", T: OrientationCheckInput },
    { no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "output", kind: "message", T: OrientationCheckOutput },
    { no: 6, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "summary", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 9, name: "warnings", kind: "message", T: Warnings, opt: true },
    { no: 10, name: "page_difference_summary", kind: "message", T: OrientationPageDifferenceSummary, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.TrimSizeCheck
 */
export class TrimSizeCheck extends Message<TrimSizeCheck> {
  /**
   * @generated from field: bool check_enabled = 1;
   */
  checkEnabled = false;

  /**
   * @generated from field: preflight.v2.TrimSizeCheckInput input = 2;
   */
  input?: TrimSizeCheckInput;

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

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

  /**
   * @generated from field: preflight.v2.TrimSizeCheckOutput output = 5;
   */
  output?: TrimSizeCheckOutput;

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

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 8;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 9;
   */
  warnings?: Warnings;

  /**
   * @generated from field: optional preflight.v2.PageDifferenceSummary page_difference_summary = 10;
   */
  pageDifferenceSummary?: PageDifferenceSummary;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.TrimSizeCheck";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "check_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "input", kind: "message", T: TrimSizeCheckInput },
    { no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "output", kind: "message", T: TrimSizeCheckOutput },
    { no: 6, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "summary", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 9, name: "warnings", kind: "message", T: Warnings, opt: true },
    { no: 10, name: "page_difference_summary", kind: "message", T: PageDifferenceSummary, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.BoxSizeCheck
 */
export class BoxSizeCheck extends Message<BoxSizeCheck> {
  /**
   * @generated from field: bool check_enabled = 1;
   */
  checkEnabled = false;

  /**
   * TrimSizeCheckInput input = 2;
   *
   * @generated from field: string key = 3;
   */
  key = "";

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

  /**
   * @generated from field: preflight.v2.BoxSizeCheckOutput output = 5;
   */
  output?: BoxSizeCheckOutput;

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

  /**
   * @generated from field: optional preflight.v2.PageDifferenceSummary page_difference_summary = 7;
   */
  pageDifferenceSummary?: PageDifferenceSummary;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.BoxSizeCheck";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "check_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "output", kind: "message", T: BoxSizeCheckOutput },
    { no: 6, name: "summary", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "page_difference_summary", kind: "message", T: PageDifferenceSummary, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.BoxSizeCheckOutput
 */
export class BoxSizeCheckOutput extends Message<BoxSizeCheckOutput> {
  /**
   * @generated from field: float width = 1;
   */
  width = 0;

  /**
   * @generated from field: float height = 2;
   */
  height = 0;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.BoxSizeCheckOutput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "width", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "height", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 3, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.FontsEmbeddedCheck
 */
export class FontsEmbeddedCheck extends Message<FontsEmbeddedCheck> {
  /**
   * @generated from field: bool check_enabled = 1;
   */
  checkEnabled = false;

  /**
   * @generated from field: preflight.v2.FontsEmbeddedCheckInput input = 2;
   */
  input?: FontsEmbeddedCheckInput;

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

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

  /**
   * @generated from field: preflight.v2.FontsEmbeddedCheckOutput output = 5;
   */
  output?: FontsEmbeddedCheckOutput;

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

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 8;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 9;
   */
  warnings?: Warnings;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.FontsEmbeddedCheck";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "check_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "input", kind: "message", T: FontsEmbeddedCheckInput },
    { no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "output", kind: "message", T: FontsEmbeddedCheckOutput },
    { no: 6, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "summary", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 9, name: "warnings", kind: "message", T: Warnings, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ImageResolutionCheck
 */
export class ImageResolutionCheck extends Message<ImageResolutionCheck> {
  /**
   * @generated from field: bool check_enabled = 1;
   */
  checkEnabled = false;

  /**
   * @generated from field: preflight.v2.ImageResolutionCheckInput input = 2;
   */
  input?: ImageResolutionCheckInput;

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

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

  /**
   * @generated from field: preflight.v2.ImageResolutionCheckOutput output = 5;
   */
  output?: ImageResolutionCheckOutput;

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

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

  /**
   * @generated from field: optional preflight.v2.Failures failures = 8;
   */
  failures?: Failures;

  /**
   * @generated from field: optional preflight.v2.Warnings warnings = 9;
   */
  warnings?: Warnings;

  /**
   * @generated from field: optional preflight.v2.ImageResolutionPageDifferenceSummary page_difference_summary = 10;
   */
  pageDifferenceSummary?: ImageResolutionPageDifferenceSummary;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ImageResolutionCheck";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "check_enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "input", kind: "message", T: ImageResolutionCheckInput },
    { no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "output", kind: "message", T: ImageResolutionCheckOutput },
    { no: 6, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "summary", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "failures", kind: "message", T: Failures, opt: true },
    { no: 9, name: "warnings", kind: "message", T: Warnings, opt: true },
    { no: 10, name: "page_difference_summary", kind: "message", T: ImageResolutionPageDifferenceSummary, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.PageCountCheckInput
 */
export class PageCountCheckInput extends Message<PageCountCheckInput> {
  /**
   * @generated from field: int32 expected_page_count = 1;
   */
  expectedPageCount = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.PageCountCheckInput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "expected_page_count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ColourCheckInput
 */
export class ColourCheckInput extends Message<ColourCheckInput> {
  /**
   * @generated from field: repeated string allowed_colours = 1;
   */
  allowedColours: string[] = [];

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

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

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

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

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

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

/**
 * @generated from message preflight.v2.AspectRatioCheckInput
 */
export class AspectRatioCheckInput extends Message<AspectRatioCheckInput> {
  /**
   * @generated from field: float pass_tolerance_percentage = 1;
   */
  passTolerancePercentage = 0;

  /**
   * @generated from field: float warn_tolerance_percentage = 2;
   */
  warnTolerancePercentage = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.AspectRatioCheckInput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "pass_tolerance_percentage", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "warn_tolerance_percentage", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.BleedCheckInput
 */
export class BleedCheckInput extends Message<BleedCheckInput> {
  /**
   * @generated from field: float bottom = 1;
   */
  bottom = 0;

  /**
   * @generated from field: float left = 2;
   */
  left = 0;

  /**
   * @generated from field: float right = 3;
   */
  right = 0;

  /**
   * @generated from field: float top = 4;
   */
  top = 0;

  /**
   * "mm"
   *
   * @generated from field: string unit = 5;
   */
  unit = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.BleedCheckInput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "bottom", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "left", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 3, name: "right", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 4, name: "top", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 5, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.OrientationCheckInput
 */
export class OrientationCheckInput extends Message<OrientationCheckInput> {
  /**
   * "Portrait"
   *
   * @generated from field: string orientation = 1;
   */
  orientation = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.OrientationCheckInput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "orientation", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.TrimSizeCheckInput
 */
export class TrimSizeCheckInput extends Message<TrimSizeCheckInput> {
  /**
   * @generated from field: float width = 1;
   */
  width = 0;

  /**
   * @generated from field: float height = 2;
   */
  height = 0;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.TrimSizeCheckInput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "width", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "height", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 3, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * The original JSON had `input: null`. Potentially empty or future fields go here.
 *
 * @generated from message preflight.v2.FontsEmbeddedCheckInput
 */
export class FontsEmbeddedCheckInput extends Message<FontsEmbeddedCheckInput> {
  constructor(data?: PartialMessage<FontsEmbeddedCheckInput>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.FontsEmbeddedCheckInput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ImageResolutionCheckInput
 */
export class ImageResolutionCheckInput extends Message<ImageResolutionCheckInput> {
  /**
   * "actual size"
   *
   * @generated from field: string check_resolution_size = 1;
   */
  checkResolutionSize = "";

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

  /**
   * @generated from field: int32 recomended_d_p_i = 3;
   */
  recomendedDPI = 0;

  /**
   * @generated from field: int32 warn_below_d_p_i = 4;
   */
  warnBelowDPI = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ImageResolutionCheckInput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "check_resolution_size", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "error_below_d_p_i", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 3, name: "recomended_d_p_i", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 4, name: "warn_below_d_p_i", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.PageCountCheckOutput
 */
export class PageCountCheckOutput extends Message<PageCountCheckOutput> {
  /**
   * @generated from field: int32 actual_page_count = 1;
   */
  actualPageCount = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.PageCountCheckOutput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "actual_page_count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ColourCheckOutput
 */
export class ColourCheckOutput extends Message<ColourCheckOutput> {
  /**
   * e.g. "CMYK"
   *
   * @generated from field: repeated string colours_found = 1;
   */
  coloursFound: string[] = [];

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

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

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

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

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

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

/**
 * @generated from message preflight.v2.AspectRatioCheckOutput
 */
export class AspectRatioCheckOutput extends Message<AspectRatioCheckOutput> {
  /**
   * @generated from field: optional bool all_pages_uniform = 1;
   */
  allPagesUniform?: boolean;

  /**
   * @generated from field: float aspect_ratio = 2;
   */
  aspectRatio = 0;

  /**
   * @generated from field: float deviation_percentage = 3;
   */
  deviationPercentage = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.AspectRatioCheckOutput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "all_pages_uniform", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 2, name: "aspect_ratio", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 3, name: "deviation_percentage", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.BleedCheckOutput
 */
export class BleedCheckOutput extends Message<BleedCheckOutput> {
  /**
   * @generated from field: optional bool all_pages_uniform = 1;
   */
  allPagesUniform?: boolean;

  /**
   * @generated from field: float bottom = 2;
   */
  bottom = 0;

  /**
   * @generated from field: float left = 3;
   */
  left = 0;

  /**
   * @generated from field: float right = 4;
   */
  right = 0;

  /**
   * @generated from field: float top = 5;
   */
  top = 0;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.BleedCheckOutput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "all_pages_uniform", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 2, name: "bottom", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 3, name: "left", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 4, name: "right", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 5, name: "top", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 6, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.OrientationCheckOutput
 */
export class OrientationCheckOutput extends Message<OrientationCheckOutput> {
  /**
   * @generated from field: optional bool all_pages_uniform = 1;
   */
  allPagesUniform?: boolean;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.OrientationCheckOutput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "all_pages_uniform", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 2, name: "orientation", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.TrimSizeCheckOutput
 */
export class TrimSizeCheckOutput extends Message<TrimSizeCheckOutput> {
  /**
   * @generated from field: optional bool all_pages_uniform = 1;
   */
  allPagesUniform?: boolean;

  /**
   * @generated from field: float width = 2;
   */
  width = 0;

  /**
   * @generated from field: float height = 3;
   */
  height = 0;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.TrimSizeCheckOutput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "all_pages_uniform", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 2, name: "width", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 3, name: "height", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 4, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.FontsEmbeddedCheckOutput
 */
export class FontsEmbeddedCheckOutput extends Message<FontsEmbeddedCheckOutput> {
  /**
   * deprecated in favour of "fonts"
   *
   * @generated from field: repeated string fonts_found = 1;
   */
  fontsFound: string[] = [];

  /**
   * @generated from field: repeated preflight.v2.FontsEmbeddedCheckOutput.Font fonts = 2;
   */
  fonts: FontsEmbeddedCheckOutput_Font[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.FontsEmbeddedCheckOutput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "fonts_found", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 2, name: "fonts", kind: "message", T: FontsEmbeddedCheckOutput_Font, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.FontsEmbeddedCheckOutput.Font
 */
export class FontsEmbeddedCheckOutput_Font extends Message<FontsEmbeddedCheckOutput_Font> {
  /**
   * @generated from field: string name = 1;
   */
  name = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.FontsEmbeddedCheckOutput.Font";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "embedded", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ImageResolutionCheckOutput
 */
export class ImageResolutionCheckOutput extends Message<ImageResolutionCheckOutput> {
  /**
   * @generated from field: float min_image_resolution_d_p_i = 1;
   */
  minImageResolutionDPI = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ImageResolutionCheckOutput";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "min_image_resolution_d_p_i", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.Failures
 */
export class Failures extends Message<Failures> {
  /**
   * @generated from field: repeated int32 affected_pages = 1;
   */
  affectedPages: number[] = [];

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.Failures";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "affected_pages", kind: "scalar", T: 5 /* ScalarType.INT32 */, repeated: true },
    { no: 2, name: "count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.Warnings
 */
export class Warnings extends Message<Warnings> {
  /**
   * @generated from field: repeated int32 affected_pages = 1;
   */
  affectedPages: number[] = [];

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.Warnings";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "affected_pages", kind: "scalar", T: 5 /* ScalarType.INT32 */, repeated: true },
    { no: 2, name: "count", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.PreflightMediaItem
 */
export class PreflightMediaItem extends Message<PreflightMediaItem> {
  /**
   * @generated from field: int64 media_item_id = 1;
   */
  mediaItemId = protoInt64.zero;

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

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

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

  /**
   * @generated from field: string content_type = 5;
   */
  contentType = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.PreflightMediaItem";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "media_item_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 2, name: "file_num", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 3, name: "bucket_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "object_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "content_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.StartPreflightRequest
 */
export class StartPreflightRequest extends Message<StartPreflightRequest> {
  /**
   * @generated from field: common.v1.ObjectRef object_ref = 1;
   */
  objectRef?: ObjectRef;

  /**
   * @generated from field: repeated preflight.v2.PreflightMediaItem media_items = 2;
   */
  mediaItems: PreflightMediaItem[] = [];

  /**
   * @generated from field: int64 artworker_id = 3;
   */
  artworkerId = protoInt64.zero;

  /**
   * @generated from field: common.v1.ObjectRef preflight_config_object_ref = 4;
   */
  preflightConfigObjectRef?: ObjectRef;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.StartPreflightRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "object_ref", kind: "message", T: ObjectRef },
    { no: 2, name: "media_items", kind: "message", T: PreflightMediaItem, repeated: true },
    { no: 3, name: "artworker_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 4, name: "preflight_config_object_ref", kind: "message", T: ObjectRef },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.StartPreflightResponse
 */
export class StartPreflightResponse extends Message<StartPreflightResponse> {
  /**
   * @generated from field: bool ok = 1;
   */
  ok = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.StartPreflightResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ok", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.GetPreflightFileReportRequest
 */
export class GetPreflightFileReportRequest extends Message<GetPreflightFileReportRequest> {
  /**
   * @generated from field: int64 media_item_id = 1;
   */
  mediaItemId = protoInt64.zero;

  /**
   * @generated from field: int64 artworker_id = 2;
   */
  artworkerId = protoInt64.zero;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.GetPreflightFileReportRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "media_item_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 2, name: "artworker_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.GetPreflightFileReportResponse
 */
export class GetPreflightFileReportResponse extends Message<GetPreflightFileReportResponse> {
  /**
   * @generated from field: preflight.v2.PreflightFileReport report = 1;
   */
  report?: PreflightFileReport;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.GetPreflightFileReportResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "report", kind: "message", T: PreflightFileReport },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.GetPreflightPageReportRequest
 */
export class GetPreflightPageReportRequest extends Message<GetPreflightPageReportRequest> {
  /**
   * @generated from field: int64 media_item_id = 1;
   */
  mediaItemId = protoInt64.zero;

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

  /**
   * @generated from field: int64 artworker_id = 3;
   */
  artworkerId = protoInt64.zero;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.GetPreflightPageReportRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "media_item_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 2, name: "page", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 3, name: "artworker_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.GetPreflightPageReportResponse
 */
export class GetPreflightPageReportResponse extends Message<GetPreflightPageReportResponse> {
  /**
   * @generated from field: preflight.v2.PreflightPageReport report = 1;
   */
  report?: PreflightPageReport;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.GetPreflightPageReportResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "report", kind: "message", T: PreflightPageReport },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.PageDifferenceSummary
 */
export class PageDifferenceSummary extends Message<PageDifferenceSummary> {
  /**
   * @generated from field: repeated preflight.v2.TrimSizeDifference differences = 1;
   */
  differences: TrimSizeDifference[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.PageDifferenceSummary";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "differences", kind: "message", T: TrimSizeDifference, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.TrimSizeDifference
 */
export class TrimSizeDifference extends Message<TrimSizeDifference> {
  /**
   * @generated from field: preflight.v2.TrimSizeConfig config = 1;
   */
  config?: TrimSizeConfig;

  /**
   * @generated from field: repeated int32 pages = 2;
   */
  pages: number[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.TrimSizeDifference";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "config", kind: "message", T: TrimSizeConfig },
    { no: 2, name: "pages", kind: "scalar", T: 5 /* ScalarType.INT32 */, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.TrimSizeConfig
 */
export class TrimSizeConfig extends Message<TrimSizeConfig> {
  /**
   * @generated from field: float height = 1;
   */
  height = 0;

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

  /**
   * @generated from field: float width = 3;
   */
  width = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.TrimSizeConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "height", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "width", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.BleedPageDifferenceSummary
 */
export class BleedPageDifferenceSummary extends Message<BleedPageDifferenceSummary> {
  /**
   * @generated from field: repeated preflight.v2.BleedDifference differences = 1;
   */
  differences: BleedDifference[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.BleedPageDifferenceSummary";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "differences", kind: "message", T: BleedDifference, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.BleedDifference
 */
export class BleedDifference extends Message<BleedDifference> {
  /**
   * @generated from field: preflight.v2.BleedConfig config = 1;
   */
  config?: BleedConfig;

  /**
   * @generated from field: repeated int32 pages = 2;
   */
  pages: number[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.BleedDifference";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "config", kind: "message", T: BleedConfig },
    { no: 2, name: "pages", kind: "scalar", T: 5 /* ScalarType.INT32 */, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.BleedConfig
 */
export class BleedConfig extends Message<BleedConfig> {
  /**
   * @generated from field: float bottom = 1;
   */
  bottom = 0;

  /**
   * @generated from field: float left = 2;
   */
  left = 0;

  /**
   * @generated from field: float right = 3;
   */
  right = 0;

  /**
   * @generated from field: float top = 4;
   */
  top = 0;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.BleedConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "bottom", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 2, name: "left", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 3, name: "right", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 4, name: "top", kind: "scalar", T: 2 /* ScalarType.FLOAT */ },
    { no: 5, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.OrientationPageDifferenceSummary
 */
export class OrientationPageDifferenceSummary extends Message<OrientationPageDifferenceSummary> {
  /**
   * @generated from field: repeated preflight.v2.OrientationDifference differences = 1;
   */
  differences: OrientationDifference[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.OrientationPageDifferenceSummary";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "differences", kind: "message", T: OrientationDifference, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.OrientationDifference
 */
export class OrientationDifference extends Message<OrientationDifference> {
  /**
   * @generated from field: preflight.v2.OrientationConfig config = 1;
   */
  config?: OrientationConfig;

  /**
   * @generated from field: repeated int32 pages = 2;
   */
  pages: number[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.OrientationDifference";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "config", kind: "message", T: OrientationConfig },
    { no: 2, name: "pages", kind: "scalar", T: 5 /* ScalarType.INT32 */, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.OrientationConfig
 */
export class OrientationConfig extends Message<OrientationConfig> {
  /**
   * @generated from field: string orientation = 1;
   */
  orientation = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.OrientationConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "orientation", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ColourPageDifferenceSummary
 */
export class ColourPageDifferenceSummary extends Message<ColourPageDifferenceSummary> {
  /**
   * @generated from field: repeated preflight.v2.ColourDifference differences = 1;
   */
  differences: ColourDifference[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ColourPageDifferenceSummary";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "differences", kind: "message", T: ColourDifference, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ColourDifference
 */
export class ColourDifference extends Message<ColourDifference> {
  /**
   * @generated from field: preflight.v2.ColourConfig config = 1;
   */
  config?: ColourConfig;

  /**
   * @generated from field: repeated int32 pages = 2;
   */
  pages: number[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ColourDifference";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "config", kind: "message", T: ColourConfig },
    { no: 2, name: "pages", kind: "scalar", T: 5 /* ScalarType.INT32 */, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ColourConfig
 */
export class ColourConfig extends Message<ColourConfig> {
  /**
   * @generated from field: string colour = 1;
   */
  colour = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ColourConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "colour", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ImageResolutionPageDifferenceSummary
 */
export class ImageResolutionPageDifferenceSummary extends Message<ImageResolutionPageDifferenceSummary> {
  /**
   * @generated from field: repeated preflight.v2.ImageResolutionDifference differences = 1;
   */
  differences: ImageResolutionDifference[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ImageResolutionPageDifferenceSummary";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "differences", kind: "message", T: ImageResolutionDifference, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ImageResolutionDifference
 */
export class ImageResolutionDifference extends Message<ImageResolutionDifference> {
  /**
   * @generated from field: preflight.v2.ImageResolutionConfig config = 1;
   */
  config?: ImageResolutionConfig;

  /**
   * @generated from field: repeated int32 pages = 2;
   */
  pages: number[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ImageResolutionDifference";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "config", kind: "message", T: ImageResolutionConfig },
    { no: 2, name: "pages", kind: "scalar", T: 5 /* ScalarType.INT32 */, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message preflight.v2.ImageResolutionConfig
 */
export class ImageResolutionConfig extends Message<ImageResolutionConfig> {
  /**
   * @generated from field: string status = 1;
   */
  status = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "preflight.v2.ImageResolutionConfig";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "status", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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