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

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { MeasurementUnit } from "../../common/v1/unit_pb.js";

/**
 * @generated from message artworking.v1.FixupResults
 */
export class FixupResults extends Message<FixupResults> {
  /**
   * @generated from field: bool passed = 1;
   */
  passed = false;

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

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

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

  /**
   * @generated from field: repeated string fixups = 5;
   */
  fixups: string[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.FixupResults";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "passed", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "num_success", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 3, name: "num_fail", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 4, name: "error", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 5, name: "fixups", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.FixupOptions
 */
export class FixupOptions extends Message<FixupOptions> {
  /**
   * @generated from field: optional artworking.v1.RemovePrinterMarksOptions remove_printer_marks = 1;
   */
  removePrinterMarks?: RemovePrinterMarksOptions;

  /**
   * @generated from field: optional artworking.v1.AddCropMarksOptions add_crop_marks = 2;
   */
  addCropMarks?: AddCropMarksOptions;

  /**
   * @generated from field: optional artworking.v1.PageRotationOptions page_rotation = 3;
   */
  pageRotation?: PageRotationOptions;

  /**
   * @generated from field: optional artworking.v1.RemovePageOptions remove_page = 4;
   */
  removePage?: RemovePageOptions;

  /**
   * optional AddPageOptions add_page = 5;
   *
   * @generated from field: optional artworking.v1.SplitPageOptions split_page = 6;
   */
  splitPage?: SplitPageOptions;

  /**
   * @generated from field: optional artworking.v1.BleedboxFixGeometryOptions bleedbox_fix_geometry = 7;
   */
  bleedboxFixGeometry?: BleedboxFixGeometryOptions;

  /**
   * @generated from field: optional artworking.v1.OptimisePDFOptions optimise_p_d_f = 8;
   */
  optimisePDF?: OptimisePDFOptions;

  /**
   * @generated from field: optional artworking.v1.RenameLayerOptions rename_layer = 9;
   */
  renameLayer?: RenameLayerOptions;

  /**
   * @generated from field: optional artworking.v1.RemoveLayerOptions remove_layer = 10;
   */
  removeLayer?: RemoveLayerOptions;

  /**
   * @generated from field: optional artworking.v1.RemoveContentFromLayerOptions remove_content_from_layer = 11;
   */
  removeContentFromLayer?: RemoveContentFromLayerOptions;

  /**
   * @generated from field: optional artworking.v1.FlattenLayersOptions flatten_layers = 12;
   */
  flattenLayers?: FlattenLayersOptions;

  /**
   * @generated from field: optional artworking.v1.SplitInHalfOptions split_in_half = 13;
   */
  splitInHalf?: SplitInHalfOptions;

  /**
   * @generated from field: optional artworking.v1.ReaderSpreadsOptions reader_spreads = 14;
   */
  readerSpreads?: ReaderSpreadsOptions;

  /**
   * @generated from field: optional artworking.v1.GenerateBleedOptions generate_bleed = 15;
   */
  generateBleed?: GenerateBleedOptions;

  /**
   * @generated from field: optional artworking.v1.KnockoutWhiteOptions knockout_white = 16;
   */
  knockoutWhite?: KnockoutWhiteOptions;

  /**
   * @generated from field: optional artworking.v1.OverprintBlackTextOptions overprint_black_text = 17;
   */
  overprintBlackText?: OverprintBlackTextOptions;

  /**
   * @generated from field: optional artworking.v1.ConvertTextToOutlinesOptions convert_text_to_outlines = 18;
   */
  convertTextToOutlines?: ConvertTextToOutlinesOptions;

  /**
   * @generated from field: optional artworking.v1.EmbedOutputIntentOptions embed_output_intent = 19;
   */
  embedOutputIntent?: EmbedOutputIntentOptions;

  /**
   * @generated from field: optional artworking.v1.ResizePageOptions resize_page = 20;
   */
  resizePage?: ResizePageOptions;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.FixupOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "remove_printer_marks", kind: "message", T: RemovePrinterMarksOptions, opt: true },
    { no: 2, name: "add_crop_marks", kind: "message", T: AddCropMarksOptions, opt: true },
    { no: 3, name: "page_rotation", kind: "message", T: PageRotationOptions, opt: true },
    { no: 4, name: "remove_page", kind: "message", T: RemovePageOptions, opt: true },
    { no: 6, name: "split_page", kind: "message", T: SplitPageOptions, opt: true },
    { no: 7, name: "bleedbox_fix_geometry", kind: "message", T: BleedboxFixGeometryOptions, opt: true },
    { no: 8, name: "optimise_p_d_f", kind: "message", T: OptimisePDFOptions, opt: true },
    { no: 9, name: "rename_layer", kind: "message", T: RenameLayerOptions, opt: true },
    { no: 10, name: "remove_layer", kind: "message", T: RemoveLayerOptions, opt: true },
    { no: 11, name: "remove_content_from_layer", kind: "message", T: RemoveContentFromLayerOptions, opt: true },
    { no: 12, name: "flatten_layers", kind: "message", T: FlattenLayersOptions, opt: true },
    { no: 13, name: "split_in_half", kind: "message", T: SplitInHalfOptions, opt: true },
    { no: 14, name: "reader_spreads", kind: "message", T: ReaderSpreadsOptions, opt: true },
    { no: 15, name: "generate_bleed", kind: "message", T: GenerateBleedOptions, opt: true },
    { no: 16, name: "knockout_white", kind: "message", T: KnockoutWhiteOptions, opt: true },
    { no: 17, name: "overprint_black_text", kind: "message", T: OverprintBlackTextOptions, opt: true },
    { no: 18, name: "convert_text_to_outlines", kind: "message", T: ConvertTextToOutlinesOptions, opt: true },
    { no: 19, name: "embed_output_intent", kind: "message", T: EmbedOutputIntentOptions, opt: true },
    { no: 20, name: "resize_page", kind: "message", T: ResizePageOptions, opt: true },
  ]);

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

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

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

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

/**
 * Nested Option Messages
 *
 * @generated from message artworking.v1.RemovePrinterMarksOptions
 */
export class RemovePrinterMarksOptions extends Message<RemovePrinterMarksOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: artworking.v1.FixupResults results = 2;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.RemovePrinterMarksOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.AddCropMarksOptions
 */
export class AddCropMarksOptions extends Message<AddCropMarksOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: artworking.v1.FixupResults results = 2;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.AddCropMarksOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.PageRotationOptions
 */
export class PageRotationOptions extends Message<PageRotationOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: optional double angle = 2;
   */
  angle?: number;

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

  /**
   * @generated from field: artworking.v1.FixupResults results = 4;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.PageRotationOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "angle", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
    { no: 3, name: "page_selector", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 4, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.RemovePageOptions
 */
export class RemovePageOptions extends Message<RemovePageOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

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

  /**
   * @generated from field: artworking.v1.FixupResults results = 3;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.RemovePageOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "page_selector", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 3, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.SplitPageOptions
 */
export class SplitPageOptions extends Message<SplitPageOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

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

  /**
   * @generated from field: optional bool reorder_page = 3;
   */
  reorderPage?: boolean;

  /**
   * @generated from field: artworking.v1.FixupResults results = 4;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.SplitPageOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "page_selector", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 3, name: "reorder_page", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 4, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.BleedboxFixGeometryOptions
 */
export class BleedboxFixGeometryOptions extends Message<BleedboxFixGeometryOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: artworking.v1.FixupResults results = 2;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.BleedboxFixGeometryOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.OptimisePDFOptions
 */
export class OptimisePDFOptions extends Message<OptimisePDFOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: artworking.v1.FixupResults results = 2;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.OptimisePDFOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.RenameLayerOptions
 */
export class RenameLayerOptions extends Message<RenameLayerOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

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

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

  /**
   * @generated from field: artworking.v1.FixupResults results = 4;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.RenameLayerOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "layer_regex", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 3, name: "new_name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 4, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.RemoveLayerOptions
 */
export class RemoveLayerOptions extends Message<RemoveLayerOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

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

  /**
   * @generated from field: artworking.v1.FixupResults results = 3;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.RemoveLayerOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "layer_regex", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 3, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.RemoveContentFromLayerOptions
 */
export class RemoveContentFromLayerOptions extends Message<RemoveContentFromLayerOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: artworking.v1.FixupResults results = 2;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.RemoveContentFromLayerOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.FlattenLayersOptions
 */
export class FlattenLayersOptions extends Message<FlattenLayersOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: artworking.v1.FixupResults results = 2;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.FlattenLayersOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.SplitInHalfOptions
 */
export class SplitInHalfOptions extends Message<SplitInHalfOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: artworking.v1.FixupResults results = 2;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.SplitInHalfOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.ReaderSpreadsOptions
 */
export class ReaderSpreadsOptions extends Message<ReaderSpreadsOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: optional bool cover_page = 2;
   */
  coverPage?: boolean;

  /**
   * @generated from field: artworking.v1.FixupResults results = 3;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.ReaderSpreadsOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "cover_page", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 3, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.GenerateBleedOptions
 */
export class GenerateBleedOptions extends Message<GenerateBleedOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: optional double size_left = 2;
   */
  sizeLeft?: number;

  /**
   * @generated from field: optional double size_right = 3;
   */
  sizeRight?: number;

  /**
   * @generated from field: optional double size_top = 4;
   */
  sizeTop?: number;

  /**
   * @generated from field: optional double size_bottom = 5;
   */
  sizeBottom?: number;

  /**
   * @generated from field: optional double min_check = 6;
   */
  minCheck?: number;

  /**
   * "mirror", "pixel repetition", "stretch"
   *
   * @generated from field: optional string method = 7;
   */
  method?: string;

  /**
   * @generated from field: optional bool generate_on_layer = 8;
   */
  generateOnLayer?: boolean;

  /**
   * @generated from field: optional string bleed_layer_name = 9;
   */
  bleedLayerName?: string;

  /**
   * @generated from field: artworking.v1.FixupResults results = 10;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.GenerateBleedOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "size_left", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
    { no: 3, name: "size_right", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
    { no: 4, name: "size_top", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
    { no: 5, name: "size_bottom", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
    { no: 6, name: "min_check", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
    { no: 7, name: "method", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 8, name: "generate_on_layer", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
    { no: 9, name: "bleed_layer_name", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 10, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.KnockoutWhiteOptions
 */
export class KnockoutWhiteOptions extends Message<KnockoutWhiteOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * "Text", "Vector", "Vector-Text"
   *
   * @generated from field: optional string apply_to = 2;
   */
  applyTo?: string;

  /**
   * @generated from field: artworking.v1.FixupResults results = 3;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.KnockoutWhiteOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "apply_to", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 3, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.OverprintBlackTextOptions
 */
export class OverprintBlackTextOptions extends Message<OverprintBlackTextOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: optional double min_text_size = 2;
   */
  minTextSize?: number;

  /**
   * @generated from field: artworking.v1.FixupResults results = 3;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.OverprintBlackTextOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "min_text_size", kind: "scalar", T: 1 /* ScalarType.DOUBLE */, opt: true },
    { no: 3, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.ConvertTextToOutlinesOptions
 */
export class ConvertTextToOutlinesOptions extends Message<ConvertTextToOutlinesOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: artworking.v1.FixupResults results = 2;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.ConvertTextToOutlinesOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.EmbedOutputIntentOptions
 */
export class EmbedOutputIntentOptions extends Message<EmbedOutputIntentOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.EmbedOutputIntentOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "output_intent", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.ResizePageOptions
 */
export class ResizePageOptions extends Message<ResizePageOptions> {
  /**
   * @generated from field: bool enabled = 1;
   */
  enabled = false;

  /**
   * @generated from field: optional float width = 2;
   */
  width?: number;

  /**
   * @generated from field: optional float height = 3;
   */
  height?: number;

  /**
   * @generated from field: optional string method = 4;
   */
  method?: string;

  /**
   * @generated from field: artworking.v1.FixupResults results = 5;
   */
  results?: FixupResults;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.ResizePageOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "enabled", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 2, name: "width", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
    { no: 3, name: "height", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
    { no: 4, name: "method", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
    { no: 5, name: "results", kind: "message", T: FixupResults },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.FixupParams
 */
export class FixupParams extends Message<FixupParams> {
  /**
   * @generated from field: artworking.v1.FixupOptions options = 1;
   */
  options?: FixupOptions;

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

  /**
   * @generated from field: repeated artworking.v1.FixupParams.FixupOutputFilenameParams output_filenames = 3;
   */
  outputFilenames: FixupParams_FixupOutputFilenameParams[] = [];

  /**
   * @generated from field: common.v1.MeasurementUnit unit = 4;
   */
  unit = MeasurementUnit.UNKNOWN;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.FixupParams";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "options", kind: "message", T: FixupOptions },
    { no: 2, name: "page_range", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "output_filenames", kind: "message", T: FixupParams_FixupOutputFilenameParams, repeated: true },
    { no: 4, name: "unit", kind: "enum", T: proto3.getEnumType(MeasurementUnit) },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.FixupParams.FixupOutputFilenameParams
 */
export class FixupParams_FixupOutputFilenameParams extends Message<FixupParams_FixupOutputFilenameParams> {
  /**
   * @generated from field: string output_filename = 1;
   */
  outputFilename = "";

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.FixupParams.FixupOutputFilenameParams";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "output_filename", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "file_num", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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