// @generated by protoc-gen-es v1.10.1 with parameter "target=ts"
// @generated from file artworking/v1/quickfixes.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";

/**
 * PageSelector defines the page selection methods for QuickFix operations
 *
 * @generated from enum artworking.v1.PageSelector
 */
export enum PageSelector {
  /**
   * @generated from enum value: PAGE_SELECTOR_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: PAGE_SELECTOR_EVEN = 2;
   */
  EVEN = 2,

  /**
   * For specific page ranges, use custom string values like "1,3,5" or "1-10"
   * These would be handled as string fields in the actual implementation
   *
   * @generated from enum value: PAGE_SELECTOR_ODD = 3;
   */
  ODD = 3,
}
// Retrieve enum metadata with: proto3.getEnumType(PageSelector)
proto3.util.setEnumType(PageSelector, "artworking.v1.PageSelector", [
  { no: 0, name: "PAGE_SELECTOR_UNSPECIFIED" },
  { no: 1, name: "PAGE_SELECTOR_ALL" },
  { no: 2, name: "PAGE_SELECTOR_EVEN" },
  { no: 3, name: "PAGE_SELECTOR_ODD" },
]);

/**
 * Visibility defines the visibility states for layers/OCG
 *
 * @generated from enum artworking.v1.Visibility
 */
export enum Visibility {
  /**
   * @generated from enum value: VISIBILITY_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: VISIBILITY_OFF = 2;
   */
  OFF = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(Visibility)
proto3.util.setEnumType(Visibility, "artworking.v1.Visibility", [
  { no: 0, name: "VISIBILITY_UNSPECIFIED" },
  { no: 1, name: "VISIBILITY_ON" },
  { no: 2, name: "VISIBILITY_OFF" },
]);

/**
 * FlipDirection defines the direction for page flipping operations
 *
 * @generated from enum artworking.v1.FlipDirection
 */
export enum FlipDirection {
  /**
   * @generated from enum value: FLIP_DIRECTION_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: FLIP_DIRECTION_VERTICALLY = 2;
   */
  VERTICALLY = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(FlipDirection)
proto3.util.setEnumType(FlipDirection, "artworking.v1.FlipDirection", [
  { no: 0, name: "FLIP_DIRECTION_UNSPECIFIED" },
  { no: 1, name: "FLIP_DIRECTION_HORIZONTALLY" },
  { no: 2, name: "FLIP_DIRECTION_VERTICALLY" },
]);

/**
 * RelativePosition defines positioning relative to page elements
 *
 * @generated from enum artworking.v1.RelativePosition
 */
export enum RelativePosition {
  /**
   * @generated from enum value: RELATIVE_POSITION_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: RELATIVE_POSITION_LEFT_CENTER = 2;
   */
  LEFT_CENTER = 2,

  /**
   * @generated from enum value: RELATIVE_POSITION_UPPER_LEFT_CORNER = 3;
   */
  UPPER_LEFT_CORNER = 3,

  /**
   * @generated from enum value: RELATIVE_POSITION_TOP_CENTER = 4;
   */
  TOP_CENTER = 4,

  /**
   * @generated from enum value: RELATIVE_POSITION_LOWER_RIGHT_CORNER = 5;
   */
  LOWER_RIGHT_CORNER = 5,

  /**
   * @generated from enum value: RELATIVE_POSITION_RIGHT_CENTER = 6;
   */
  RIGHT_CENTER = 6,

  /**
   * @generated from enum value: RELATIVE_POSITION_UPPER_RIGHT_CORNER = 7;
   */
  UPPER_RIGHT_CORNER = 7,

  /**
   * @generated from enum value: RELATIVE_POSITION_BOTTOM_CENTER = 8;
   */
  BOTTOM_CENTER = 8,

  /**
   * @generated from enum value: RELATIVE_POSITION_CENTER = 9;
   */
  CENTER = 9,
}
// Retrieve enum metadata with: proto3.getEnumType(RelativePosition)
proto3.util.setEnumType(RelativePosition, "artworking.v1.RelativePosition", [
  { no: 0, name: "RELATIVE_POSITION_UNSPECIFIED" },
  { no: 1, name: "RELATIVE_POSITION_LOWER_LEFT_CORNER" },
  { no: 2, name: "RELATIVE_POSITION_LEFT_CENTER" },
  { no: 3, name: "RELATIVE_POSITION_UPPER_LEFT_CORNER" },
  { no: 4, name: "RELATIVE_POSITION_TOP_CENTER" },
  { no: 5, name: "RELATIVE_POSITION_LOWER_RIGHT_CORNER" },
  { no: 6, name: "RELATIVE_POSITION_RIGHT_CENTER" },
  { no: 7, name: "RELATIVE_POSITION_UPPER_RIGHT_CORNER" },
  { no: 8, name: "RELATIVE_POSITION_BOTTOM_CENTER" },
  { no: 9, name: "RELATIVE_POSITION_CENTER" },
]);

/**
 * PageScaleMode defines the scaling method for pages
 *
 * @generated from enum artworking.v1.PageScaleMode
 */
export enum PageScaleMode {
  /**
   * @generated from enum value: PAGE_SCALE_MODE_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: PAGE_SCALE_MODE_FIT_FROM_INSIDE_SCALE_PROPORTIONALLY = 2;
   */
  FIT_FROM_INSIDE_SCALE_PROPORTIONALLY = 2,

  /**
   * @generated from enum value: PAGE_SCALE_MODE_FIT_FROM_OUTSIDE_CUT_PAGE = 3;
   */
  FIT_FROM_OUTSIDE_CUT_PAGE = 3,

  /**
   * @generated from enum value: PAGE_SCALE_MODE_FIT_FROM_OUTSIDE_SCALE_PROPORTIONALLY = 4;
   */
  FIT_FROM_OUTSIDE_SCALE_PROPORTIONALLY = 4,

  /**
   * @generated from enum value: PAGE_SCALE_MODE_STRETCH_TO_FILL = 5;
   */
  STRETCH_TO_FILL = 5,
}
// Retrieve enum metadata with: proto3.getEnumType(PageScaleMode)
proto3.util.setEnumType(PageScaleMode, "artworking.v1.PageScaleMode", [
  { no: 0, name: "PAGE_SCALE_MODE_UNSPECIFIED" },
  { no: 1, name: "PAGE_SCALE_MODE_FIT_FROM_INSIDE_ADD_WHITE_SPACE" },
  { no: 2, name: "PAGE_SCALE_MODE_FIT_FROM_INSIDE_SCALE_PROPORTIONALLY" },
  { no: 3, name: "PAGE_SCALE_MODE_FIT_FROM_OUTSIDE_CUT_PAGE" },
  { no: 4, name: "PAGE_SCALE_MODE_FIT_FROM_OUTSIDE_SCALE_PROPORTIONALLY" },
  { no: 5, name: "PAGE_SCALE_MODE_STRETCH_TO_FILL" },
]);

/**
 * ProcessingStepsGroup defines the predefined processing steps groups
 *
 * @generated from enum artworking.v1.ProcessingStepsGroup
 */
export enum ProcessingStepsGroup {
  /**
   * @generated from enum value: PROCESSING_STEPS_GROUP_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: PROCESSING_STEPS_GROUP_DIMENSIONS = 2;
   */
  DIMENSIONS = 2,

  /**
   * @generated from enum value: PROCESSING_STEPS_GROUP_BRAILLE = 3;
   */
  BRAILLE = 3,

  /**
   * @generated from enum value: PROCESSING_STEPS_GROUP_LEGEND = 4;
   */
  LEGEND = 4,

  /**
   * @generated from enum value: PROCESSING_STEPS_GROUP_POSITIONS = 5;
   */
  POSITIONS = 5,

  /**
   * @generated from enum value: PROCESSING_STEPS_GROUP_WHITE = 6;
   */
  WHITE = 6,

  /**
   * @generated from enum value: PROCESSING_STEPS_GROUP_VARNISH = 7;
   */
  VARNISH = 7,
}
// Retrieve enum metadata with: proto3.getEnumType(ProcessingStepsGroup)
proto3.util.setEnumType(ProcessingStepsGroup, "artworking.v1.ProcessingStepsGroup", [
  { no: 0, name: "PROCESSING_STEPS_GROUP_UNSPECIFIED" },
  { no: 1, name: "PROCESSING_STEPS_GROUP_STRUCTURAL" },
  { no: 2, name: "PROCESSING_STEPS_GROUP_DIMENSIONS" },
  { no: 3, name: "PROCESSING_STEPS_GROUP_BRAILLE" },
  { no: 4, name: "PROCESSING_STEPS_GROUP_LEGEND" },
  { no: 5, name: "PROCESSING_STEPS_GROUP_POSITIONS" },
  { no: 6, name: "PROCESSING_STEPS_GROUP_WHITE" },
  { no: 7, name: "PROCESSING_STEPS_GROUP_VARNISH" },
]);

/**
 * Alignment defines text alignment options
 *
 * @generated from enum artworking.v1.Alignment
 */
export enum Alignment {
  /**
   * @generated from enum value: ALIGNMENT_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: ALIGNMENT_LEFT_ALIGNED = 2;
   */
  LEFT_ALIGNED = 2,

  /**
   * @generated from enum value: ALIGNMENT_CENTER_ALIGNED = 3;
   */
  CENTER_ALIGNED = 3,

  /**
   * @generated from enum value: ALIGNMENT_BLOCK_ALIGNED = 4;
   */
  BLOCK_ALIGNED = 4,
}
// Retrieve enum metadata with: proto3.getEnumType(Alignment)
proto3.util.setEnumType(Alignment, "artworking.v1.Alignment", [
  { no: 0, name: "ALIGNMENT_UNSPECIFIED" },
  { no: 1, name: "ALIGNMENT_RIGHT_ALIGNED" },
  { no: 2, name: "ALIGNMENT_LEFT_ALIGNED" },
  { no: 3, name: "ALIGNMENT_CENTER_ALIGNED" },
  { no: 4, name: "ALIGNMENT_BLOCK_ALIGNED" },
]);

/**
 * EdgeSelector defines which edges to operate on
 *
 * @generated from enum artworking.v1.EdgeSelector
 */
export enum EdgeSelector {
  /**
   * @generated from enum value: EDGE_SELECTOR_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: EDGE_SELECTOR_BOTTOM = 2;
   */
  BOTTOM = 2,

  /**
   * @generated from enum value: EDGE_SELECTOR_RIGHT = 3;
   */
  RIGHT = 3,

  /**
   * @generated from enum value: EDGE_SELECTOR_TOP = 4;
   */
  TOP = 4,

  /**
   * @generated from enum value: EDGE_SELECTOR_LEFT_AND_RIGHT = 5;
   */
  LEFT_AND_RIGHT = 5,

  /**
   * @generated from enum value: EDGE_SELECTOR_TOP_AND_BOTTOM = 6;
   */
  TOP_AND_BOTTOM = 6,

  /**
   * @generated from enum value: EDGE_SELECTOR_ALL = 7;
   */
  ALL = 7,
}
// Retrieve enum metadata with: proto3.getEnumType(EdgeSelector)
proto3.util.setEnumType(EdgeSelector, "artworking.v1.EdgeSelector", [
  { no: 0, name: "EDGE_SELECTOR_UNSPECIFIED" },
  { no: 1, name: "EDGE_SELECTOR_LEFT" },
  { no: 2, name: "EDGE_SELECTOR_BOTTOM" },
  { no: 3, name: "EDGE_SELECTOR_RIGHT" },
  { no: 4, name: "EDGE_SELECTOR_TOP" },
  { no: 5, name: "EDGE_SELECTOR_LEFT_AND_RIGHT" },
  { no: 6, name: "EDGE_SELECTOR_TOP_AND_BOTTOM" },
  { no: 7, name: "EDGE_SELECTOR_ALL" },
]);

/**
 * InsertPosition defines where to insert relative to a reference
 *
 * @generated from enum artworking.v1.InsertPosition
 */
export enum InsertPosition {
  /**
   * @generated from enum value: INSERT_POSITION_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: INSERT_POSITION_AFTER = 2;
   */
  AFTER = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(InsertPosition)
proto3.util.setEnumType(InsertPosition, "artworking.v1.InsertPosition", [
  { no: 0, name: "INSERT_POSITION_UNSPECIFIED" },
  { no: 1, name: "INSERT_POSITION_BEFORE" },
  { no: 2, name: "INSERT_POSITION_AFTER" },
]);

/**
 * PDFVersion defines the PDF version to use
 *
 * @generated from enum artworking.v1.PDFVersion
 */
export enum PDFVersion {
  /**
   * @generated from enum value: PDF_VERSION_UNSPECIFIED = 0;
   */
  PDF_VERSION_UNSPECIFIED = 0,

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

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

  /**
   * @generated from enum value: PDF_VERSION_1_5 = 3;
   */
  PDF_VERSION_1_5 = 3,

  /**
   * @generated from enum value: PDF_VERSION_1_6 = 4;
   */
  PDF_VERSION_1_6 = 4,

  /**
   * @generated from enum value: PDF_VERSION_1_7 = 5;
   */
  PDF_VERSION_1_7 = 5,

  /**
   * @generated from enum value: PDF_VERSION_2_0 = 6;
   */
  PDF_VERSION_2_0 = 6,
}
// Retrieve enum metadata with: proto3.getEnumType(PDFVersion)
proto3.util.setEnumType(PDFVersion, "artworking.v1.PDFVersion", [
  { no: 0, name: "PDF_VERSION_UNSPECIFIED" },
  { no: 1, name: "PDF_VERSION_RETAIN" },
  { no: 2, name: "PDF_VERSION_1_4" },
  { no: 3, name: "PDF_VERSION_1_5" },
  { no: 4, name: "PDF_VERSION_1_6" },
  { no: 5, name: "PDF_VERSION_1_7" },
  { no: 6, name: "PDF_VERSION_2_0" },
]);

/**
 * OutputIntentType defines the output intent types
 *
 * @generated from enum artworking.v1.OutputIntentType
 */
export enum OutputIntentType {
  /**
   * @generated from enum value: OUTPUT_INTENT_TYPE_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: OUTPUT_INTENT_TYPE_E = 2;
   */
  E = 2,

  /**
   * @generated from enum value: OUTPUT_INTENT_TYPE_X = 3;
   */
  X = 3,

  /**
   * @generated from enum value: OUTPUT_INTENT_TYPE_AE = 4;
   */
  AE = 4,

  /**
   * @generated from enum value: OUTPUT_INTENT_TYPE_AX = 5;
   */
  AX = 5,

  /**
   * @generated from enum value: OUTPUT_INTENT_TYPE_EX = 6;
   */
  EX = 6,

  /**
   * @generated from enum value: OUTPUT_INTENT_TYPE_AEX = 7;
   */
  AEX = 7,

  /**
   * @generated from enum value: OUTPUT_INTENT_TYPE_X5N = 8;
   */
  X5N = 8,
}
// Retrieve enum metadata with: proto3.getEnumType(OutputIntentType)
proto3.util.setEnumType(OutputIntentType, "artworking.v1.OutputIntentType", [
  { no: 0, name: "OUTPUT_INTENT_TYPE_UNSPECIFIED" },
  { no: 1, name: "OUTPUT_INTENT_TYPE_A" },
  { no: 2, name: "OUTPUT_INTENT_TYPE_E" },
  { no: 3, name: "OUTPUT_INTENT_TYPE_X" },
  { no: 4, name: "OUTPUT_INTENT_TYPE_AE" },
  { no: 5, name: "OUTPUT_INTENT_TYPE_AX" },
  { no: 6, name: "OUTPUT_INTENT_TYPE_EX" },
  { no: 7, name: "OUTPUT_INTENT_TYPE_AEX" },
  { no: 8, name: "OUTPUT_INTENT_TYPE_X5N" },
]);

/**
 * Operator defines the string comparison methods used in QuickFix operations
 *
 * @generated from enum artworking.v1.Operator
 */
export enum Operator {
  /**
   * @generated from enum value: OPERATOR_UNSPECIFIED = 0;
   */
  UNSPECIFIED = 0,

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

  /**
   * @generated from enum value: OPERATOR_UNEQUAL_TO = 2;
   */
  UNEQUAL_TO = 2,

  /**
   * @generated from enum value: OPERATOR_CONTAINS = 3;
   */
  CONTAINS = 3,

  /**
   * @generated from enum value: OPERATOR_DOES_NOT_CONTAIN = 4;
   */
  DOES_NOT_CONTAIN = 4,

  /**
   * @generated from enum value: OPERATOR_BEGINS_WITH = 5;
   */
  BEGINS_WITH = 5,

  /**
   * @generated from enum value: OPERATOR_DOES_NOT_BEGIN_WITH = 6;
   */
  DOES_NOT_BEGIN_WITH = 6,

  /**
   * @generated from enum value: OPERATOR_ENDS_WITH = 7;
   */
  ENDS_WITH = 7,

  /**
   * @generated from enum value: OPERATOR_DOES_NOT_END_WITH = 8;
   */
  DOES_NOT_END_WITH = 8,

  /**
   * @generated from enum value: OPERATOR_IS_CONTAINED_IN = 9;
   */
  IS_CONTAINED_IN = 9,

  /**
   * @generated from enum value: OPERATOR_IS_NOT_CONTAINED_IN = 10;
   */
  IS_NOT_CONTAINED_IN = 10,

  /**
   * @generated from enum value: OPERATOR_REGEX = 11;
   */
  REGEX = 11,
}
// Retrieve enum metadata with: proto3.getEnumType(Operator)
proto3.util.setEnumType(Operator, "artworking.v1.Operator", [
  { no: 0, name: "OPERATOR_UNSPECIFIED" },
  { no: 1, name: "OPERATOR_EQUAL_TO" },
  { no: 2, name: "OPERATOR_UNEQUAL_TO" },
  { no: 3, name: "OPERATOR_CONTAINS" },
  { no: 4, name: "OPERATOR_DOES_NOT_CONTAIN" },
  { no: 5, name: "OPERATOR_BEGINS_WITH" },
  { no: 6, name: "OPERATOR_DOES_NOT_BEGIN_WITH" },
  { no: 7, name: "OPERATOR_ENDS_WITH" },
  { no: 8, name: "OPERATOR_DOES_NOT_END_WITH" },
  { no: 9, name: "OPERATOR_IS_CONTAINED_IN" },
  { no: 10, name: "OPERATOR_IS_NOT_CONTAINED_IN" },
  { no: 11, name: "OPERATOR_REGEX" },
]);

/**
 * QuickFix represents a single quickfix operation
 *
 * @generated from message artworking.v1.Quickfix
 */
export class Quickfix extends Message<Quickfix> {
  /**
   * @generated from field: string name = 1;
   */
  name = "";

  /**
   * The specific quickfix parameters (oneof ensures only one type can be set)
   *
   * @generated from oneof artworking.v1.Quickfix.instructions
   */
  instructions: {
    /**
     * @generated from field: artworking.v1.RotatePages rotate_pages = 10;
     */
    value: RotatePages;
    case: "rotatePages";
  } | {
    /**
     * @generated from field: artworking.v1.RemovePages remove_pages = 11;
     */
    value: RemovePages;
    case: "removePages";
  } | {
    /**
     * @generated from field: artworking.v1.InsertEmptyPage insert_empty_page = 12;
     */
    value: InsertEmptyPage;
    case: "insertEmptyPage";
  } | {
    /**
     * @generated from field: artworking.v1.DuplicatePage duplicate_page = 13;
     */
    value: DuplicatePage;
    case: "duplicatePage";
  } | {
    /**
     * @generated from field: artworking.v1.ReorderPages reorder_pages = 14;
     */
    value: ReorderPages;
    case: "reorderPages";
  } | {
    /**
     * @generated from field: artworking.v1.FlipPages flip_pages = 15;
     */
    value: FlipPages;
    case: "flipPages";
  } | {
    /**
     * @generated from field: artworking.v1.ScalePages scale_pages = 16;
     */
    value: ScalePages;
    case: "scalePages";
  } | {
    /**
     * @generated from field: artworking.v1.SetPageBoxes set_page_boxes = 17;
     */
    value: SetPageBoxes;
    case: "setPageBoxes";
  } | {
    /**
     * @generated from field: artworking.v1.RenameSpotColor rename_spot_color = 18;
     */
    value: RenameSpotColor;
    case: "renameSpotColor";
  } | {
    /**
     * @generated from field: artworking.v1.MergeSpotColors merge_spot_colors = 19;
     */
    value: MergeSpotColors;
    case: "mergeSpotColors";
  } | {
    /**
     * @generated from field: artworking.v1.SetLayerVisibility set_layer_visibility = 20;
     */
    value: SetLayerVisibility;
    case: "setLayerVisibility";
  } | {
    /**
     * @generated from field: artworking.v1.SetLayerMetadata set_layer_metadata = 21;
     */
    value: SetLayerMetadata;
    case: "setLayerMetadata";
  } | {
    /**
     * @generated from field: artworking.v1.InvertPageOrder invert_page_order = 22;
     */
    value: InvertPageOrder;
    case: "invertPageOrder";
  } | {
    /**
     * @generated from field: artworking.v1.SetPageRotationKey set_page_rotation_key = 23;
     */
    value: SetPageRotationKey;
    case: "setPageRotationKey";
  } | {
    /**
     * @generated from field: artworking.v1.SetPageGeometryOrigin set_page_geometry_origin = 24;
     */
    value: SetPageGeometryOrigin;
    case: "setPageGeometryOrigin";
  } | {
    /**
     * @generated from field: artworking.v1.ExtractPages extract_pages = 25;
     */
    value: ExtractPages;
    case: "extractPages";
  } | { case: undefined; value?: undefined } = { case: undefined };

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.Quickfix";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 10, name: "rotate_pages", kind: "message", T: RotatePages, oneof: "instructions" },
    { no: 11, name: "remove_pages", kind: "message", T: RemovePages, oneof: "instructions" },
    { no: 12, name: "insert_empty_page", kind: "message", T: InsertEmptyPage, oneof: "instructions" },
    { no: 13, name: "duplicate_page", kind: "message", T: DuplicatePage, oneof: "instructions" },
    { no: 14, name: "reorder_pages", kind: "message", T: ReorderPages, oneof: "instructions" },
    { no: 15, name: "flip_pages", kind: "message", T: FlipPages, oneof: "instructions" },
    { no: 16, name: "scale_pages", kind: "message", T: ScalePages, oneof: "instructions" },
    { no: 17, name: "set_page_boxes", kind: "message", T: SetPageBoxes, oneof: "instructions" },
    { no: 18, name: "rename_spot_color", kind: "message", T: RenameSpotColor, oneof: "instructions" },
    { no: 19, name: "merge_spot_colors", kind: "message", T: MergeSpotColors, oneof: "instructions" },
    { no: 20, name: "set_layer_visibility", kind: "message", T: SetLayerVisibility, oneof: "instructions" },
    { no: 21, name: "set_layer_metadata", kind: "message", T: SetLayerMetadata, oneof: "instructions" },
    { no: 22, name: "invert_page_order", kind: "message", T: InvertPageOrder, oneof: "instructions" },
    { no: 23, name: "set_page_rotation_key", kind: "message", T: SetPageRotationKey, oneof: "instructions" },
    { no: 24, name: "set_page_geometry_origin", kind: "message", T: SetPageGeometryOrigin, oneof: "instructions" },
    { no: 25, name: "extract_pages", kind: "message", T: ExtractPages, oneof: "instructions" },
  ]);

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

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

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

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

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

  /**
   * @generated from field: repeated artworking.v1.QuickfixesParams.QuickfixesOutputFilenameParams output_filenames = 2;
   */
  outputFilenames: QuickfixesParams_QuickfixesOutputFilenameParams[] = [];

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.QuickfixesParams";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "options", kind: "message", T: QuickfixesOptions },
    { no: 2, name: "output_filenames", kind: "message", T: QuickfixesParams_QuickfixesOutputFilenameParams, repeated: true },
    { no: 3, name: "unit", kind: "enum", T: proto3.getEnumType(MeasurementUnit) },
  ]);

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.QuickfixesParams.QuickfixesOutputFilenameParams";
  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>): QuickfixesParams_QuickfixesOutputFilenameParams {
    return new QuickfixesParams_QuickfixesOutputFilenameParams().fromBinary(bytes, options);
  }

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

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

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

/**
 * QuickFixList represents a list of QuickFix operations
 *
 * @generated from message artworking.v1.QuickfixesOptions
 */
export class QuickfixesOptions extends Message<QuickfixesOptions> {
  /**
   * @generated from field: repeated artworking.v1.Quickfix quickfixes = 1;
   */
  quickfixes: Quickfix[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.QuickfixesOptions";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "quickfixes", kind: "message", T: Quickfix, repeated: true },
  ]);

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

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

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

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

/**
 * DuplicatePageInstruction represents a single duplicate page instruction
 *
 * @generated from message artworking.v1.DuplicatePageInstruction
 */
export class DuplicatePageInstruction extends Message<DuplicatePageInstruction> {
  /**
   * Which pages to duplicate: "1,-1", "all", etc.
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

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

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

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

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

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

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

/**
 * DuplicatePage represents the duplicate page quickfix operation
 *
 * @generated from message artworking.v1.DuplicatePage
 */
export class DuplicatePage extends Message<DuplicatePage> {
  /**
   * @generated from field: repeated artworking.v1.DuplicatePageInstruction instructions = 1;
   */
  instructions: DuplicatePageInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.DuplicatePage";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: DuplicatePageInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * ExtractPagesInstruction represents a single extract pages instruction
 *
 * @generated from message artworking.v1.ExtractPagesInstruction
 */
export class ExtractPagesInstruction extends Message<ExtractPagesInstruction> {
  /**
   * Page range to extract
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

  /**
   * Output file path (optional)
   *
   * @generated from field: string output_path = 2;
   */
  outputPath = "";

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

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

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

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

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

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

/**
 * ExtractPages represents the extract pages quickfix operation
 *
 * @generated from message artworking.v1.ExtractPages
 */
export class ExtractPages extends Message<ExtractPages> {
  /**
   * @generated from field: repeated artworking.v1.ExtractPagesInstruction instructions = 1;
   */
  instructions: ExtractPagesInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.ExtractPages";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: ExtractPagesInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * FlipPagesInstruction represents a single flip pages instruction
 *
 * @generated from message artworking.v1.FlipPagesInstruction
 */
export class FlipPagesInstruction extends Message<FlipPagesInstruction> {
  /**
   * Which pages to flip: "all", "even", "odd", etc.
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

  /**
   * Direction to flip the pages
   *
   * @generated from field: artworking.v1.FlipDirection flip_direction = 2;
   */
  flipDirection = FlipDirection.UNSPECIFIED;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.FlipPagesInstruction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "page_selector", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "flip_direction", kind: "enum", T: proto3.getEnumType(FlipDirection) },
  ]);

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

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

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

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

/**
 * FlipPages represents the flip pages quickfix operation
 *
 * @generated from message artworking.v1.FlipPages
 */
export class FlipPages extends Message<FlipPages> {
  /**
   * @generated from field: repeated artworking.v1.FlipPagesInstruction instructions = 1;
   */
  instructions: FlipPagesInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.FlipPages";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: FlipPagesInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * InsertEmptyPageInstruction represents a single insert empty page instruction
 *
 * @generated from message artworking.v1.InsertEmptyPageInstruction
 */
export class InsertEmptyPageInstruction extends Message<InsertEmptyPageInstruction> {
  /**
   * Where to insert: page number or selector
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

  /**
   * "before" or "after"
   *
   * @generated from field: artworking.v1.InsertPosition where = 2;
   */
  where = InsertPosition.UNSPECIFIED;

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

  /**
   * Page height
   *
   * @generated from field: double height = 4;
   */
  height = 0;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.InsertEmptyPageInstruction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "page_selector", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "where", kind: "enum", T: proto3.getEnumType(InsertPosition) },
    { no: 3, name: "width", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
    { no: 4, name: "height", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
    { no: 5, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * InsertEmptyPage represents the insert empty page quickfix operation
 *
 * @generated from message artworking.v1.InsertEmptyPage
 */
export class InsertEmptyPage extends Message<InsertEmptyPage> {
  /**
   * @generated from field: repeated artworking.v1.InsertEmptyPageInstruction instructions = 1;
   */
  instructions: InsertEmptyPageInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.InsertEmptyPage";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: InsertEmptyPageInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * InvertPageOrderInstruction represents a single invert page order instruction
 *
 * @generated from message artworking.v1.InvertPageOrderInstruction
 */
export class InvertPageOrderInstruction extends Message<InvertPageOrderInstruction> {
  /**
   * Page range to invert: "all", "1-5", etc.
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

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

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

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

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

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

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

/**
 * InvertPageOrder represents the invert page order quickfix operation
 *
 * @generated from message artworking.v1.InvertPageOrder
 */
export class InvertPageOrder extends Message<InvertPageOrder> {
  /**
   * @generated from field: repeated artworking.v1.InvertPageOrderInstruction instructions = 1;
   */
  instructions: InvertPageOrderInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.InvertPageOrder";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: InvertPageOrderInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * MergeSpotColorsInstruction represents a single merge spot colors instruction
 *
 * @generated from message artworking.v1.MergeSpotColorsInstruction
 */
export class MergeSpotColorsInstruction extends Message<MergeSpotColorsInstruction> {
  /**
   * Spot color to merge into
   *
   * @generated from field: string master_spot = 1;
   */
  masterSpot = "";

  /**
   * Spot color to be merged
   *
   * @generated from field: string slave_spot = 2;
   */
  slaveSpot = "";

  /**
   * Comparison method for master spot
   *
   * @generated from field: artworking.v1.Operator operator1 = 3;
   */
  operator1 = Operator.UNSPECIFIED;

  /**
   * Comparison method for slave spot
   *
   * @generated from field: artworking.v1.Operator operator2 = 4;
   */
  operator2 = Operator.UNSPECIFIED;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.MergeSpotColorsInstruction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "master_spot", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "slave_spot", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "operator1", kind: "enum", T: proto3.getEnumType(Operator) },
    { no: 4, name: "operator2", kind: "enum", T: proto3.getEnumType(Operator) },
  ]);

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

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

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

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

/**
 * MergeSpotColors represents the merge spot colors quickfix operation
 *
 * @generated from message artworking.v1.MergeSpotColors
 */
export class MergeSpotColors extends Message<MergeSpotColors> {
  /**
   * @generated from field: repeated artworking.v1.MergeSpotColorsInstruction instructions = 1;
   */
  instructions: MergeSpotColorsInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.MergeSpotColors";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: MergeSpotColorsInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * RemovePagesInstruction represents a single remove pages instruction
 *
 * @generated from message artworking.v1.RemovePagesInstruction
 */
export class RemovePagesInstruction extends Message<RemovePagesInstruction> {
  /**
   * Which pages to remove: "2--1", "1,3,5", etc.
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

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

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

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

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

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

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

/**
 * RemovePages represents the remove pages quickfix operation
 *
 * @generated from message artworking.v1.RemovePages
 */
export class RemovePages extends Message<RemovePages> {
  /**
   * @generated from field: repeated artworking.v1.RemovePagesInstruction instructions = 1;
   */
  instructions: RemovePagesInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.RemovePages";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: RemovePagesInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.RenameSpotColorInstruction
 */
export class RenameSpotColorInstruction extends Message<RenameSpotColorInstruction> {
  /**
   * Original spot color name
   *
   * @generated from field: string old_spot = 1;
   */
  oldSpot = "";

  /**
   * New spot color name
   *
   * @generated from field: string new_spot = 2;
   */
  newSpot = "";

  /**
   * Comparison method for matching spot color names
   *
   * @generated from field: artworking.v1.Operator operator = 3;
   */
  operator = Operator.UNSPECIFIED;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.RenameSpotColorInstruction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "old_spot", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "new_spot", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "operator", kind: "enum", T: proto3.getEnumType(Operator) },
  ]);

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

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

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

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

/**
 * RenameSpotColor represents the rename spot color quickfix operation
 *
 * @generated from message artworking.v1.RenameSpotColor
 */
export class RenameSpotColor extends Message<RenameSpotColor> {
  /**
   * @generated from field: repeated artworking.v1.RenameSpotColorInstruction instructions = 1;
   */
  instructions: RenameSpotColorInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.RenameSpotColor";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: RenameSpotColorInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * ReorderPagesInstruction represents a single reorder pages instruction
 *
 * @generated from message artworking.v1.ReorderPagesInstruction
 */
export class ReorderPagesInstruction extends Message<ReorderPagesInstruction> {
  /**
   * Which pages to reorder
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

  /**
   * Anchor point for reordering
   *
   * @generated from field: int32 page_offset = 2;
   */
  pageOffset = 0;

  /**
   * "insert_consecutive" or "shift_pages"
   *
   * @generated from field: string insert_mode = 3;
   */
  insertMode = "";

  /**
   * "insert_before" or "insert_after"
   *
   * @generated from field: string insert_pages = 4;
   */
  insertPages = "";

  /**
   * "first_page", "last_page", etc.
   *
   * @generated from field: string relative_to_page = 5;
   */
  relativeToPage = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.ReorderPagesInstruction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "page_selector", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "page_offset", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 3, name: "insert_mode", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "insert_pages", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "relative_to_page", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * ReorderPages represents the reorder pages quickfix operation
 *
 * @generated from message artworking.v1.ReorderPages
 */
export class ReorderPages extends Message<ReorderPages> {
  /**
   * @generated from field: repeated artworking.v1.ReorderPagesInstruction instructions = 1;
   */
  instructions: ReorderPagesInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.ReorderPages";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: ReorderPagesInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * RotatePagesInstruction represents a single rotate pages instruction
 *
 * @generated from message artworking.v1.RotatePagesInstruction
 */
export class RotatePagesInstruction extends Message<RotatePagesInstruction> {
  /**
   * Which pages to rotate: "all", "even", "odd", "1,3,5", etc.
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

  /**
   * Rotation angle: -270, -180, -90, 90, 180, 270
   *
   * @generated from field: int32 rotate_by = 2;
   */
  rotateBy = 0;

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

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

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

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

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

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

/**
 * RotatePages represents the rotate pages quickfix operation
 *
 * @generated from message artworking.v1.RotatePages
 */
export class RotatePages extends Message<RotatePages> {
  /**
   * @generated from field: repeated artworking.v1.RotatePagesInstruction instructions = 1;
   */
  instructions: RotatePagesInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.RotatePages";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: RotatePagesInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * ScalePagesInstruction represents a single scale pages instruction
 *
 * @generated from message artworking.v1.ScalePagesInstruction
 */
export class ScalePagesInstruction extends Message<ScalePagesInstruction> {
  /**
   * Which pages to scale
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

  /**
   * Short edge dimension
   *
   * @generated from field: double short_edge = 2;
   */
  shortEdge = 0;

  /**
   * Long edge dimension
   *
   * @generated from field: double long_edge = 3;
   */
  longEdge = 0;

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

  /**
   * Scaling method
   *
   * @generated from field: artworking.v1.PageScaleMode page_scale_mode = 5;
   */
  pageScaleMode = PageScaleMode.UNSPECIFIED;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.ScalePagesInstruction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "page_selector", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "short_edge", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
    { no: 3, name: "long_edge", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
    { no: 4, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "page_scale_mode", kind: "enum", T: proto3.getEnumType(PageScaleMode) },
  ]);

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

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

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

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

/**
 * ScalePages represents the scale pages quickfix operation
 *
 * @generated from message artworking.v1.ScalePages
 */
export class ScalePages extends Message<ScalePages> {
  /**
   * @generated from field: repeated artworking.v1.ScalePagesInstruction instructions = 1;
   */
  instructions: ScalePagesInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.ScalePages";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: ScalePagesInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * SetLayerMetadataInstruction represents a single set layer metadata instruction
 *
 * @generated from message artworking.v1.SetLayerMetadataInstruction
 */
export class SetLayerMetadataInstruction extends Message<SetLayerMetadataInstruction> {
  /**
   * Layer name to target
   *
   * @generated from field: string ocg_name = 1;
   */
  ocgName = "";

  /**
   * String comparison method
   *
   * @generated from field: artworking.v1.Operator operator = 2;
   */
  operator = Operator.UNSPECIFIED;

  /**
   * Predefined processing steps group
   *
   * @generated from field: artworking.v1.ProcessingStepsGroup processing_steps_group = 3;
   */
  processingStepsGroup = ProcessingStepsGroup.UNSPECIFIED;

  /**
   * Predefined or custom type
   *
   * @generated from field: string processing_steps_type = 4;
   */
  processingStepsType = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.SetLayerMetadataInstruction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ocg_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "operator", kind: "enum", T: proto3.getEnumType(Operator) },
    { no: 3, name: "processing_steps_group", kind: "enum", T: proto3.getEnumType(ProcessingStepsGroup) },
    { no: 4, name: "processing_steps_type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * SetLayerMetadata represents the set layer metadata quickfix operation
 *
 * @generated from message artworking.v1.SetLayerMetadata
 */
export class SetLayerMetadata extends Message<SetLayerMetadata> {
  /**
   * @generated from field: repeated artworking.v1.SetLayerMetadataInstruction instructions = 1;
   */
  instructions: SetLayerMetadataInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.SetLayerMetadata";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: SetLayerMetadataInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * SetLayerVisibilityInstruction represents a single set layer visibility instruction
 *
 * @generated from message artworking.v1.SetLayerVisibilityInstruction
 */
export class SetLayerVisibilityInstruction extends Message<SetLayerVisibilityInstruction> {
  /**
   * Layer name to target
   *
   * @generated from field: string ocg_name = 1;
   */
  ocgName = "";

  /**
   * String comparison method
   *
   * @generated from field: artworking.v1.Operator operator = 2;
   */
  operator = Operator.UNSPECIFIED;

  /**
   * Use Processing Steps metadata
   *
   * @generated from field: bool interpret_ocg_name_as_processing_steps_name = 3;
   */
  interpretOcgNameAsProcessingStepsName = false;

  /**
   * Layer visibility state
   *
   * @generated from field: artworking.v1.Visibility visibility = 4;
   */
  visibility = Visibility.UNSPECIFIED;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.SetLayerVisibilityInstruction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ocg_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "operator", kind: "enum", T: proto3.getEnumType(Operator) },
    { no: 3, name: "interpret_ocg_name_as_processing_steps_name", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 4, name: "visibility", kind: "enum", T: proto3.getEnumType(Visibility) },
  ]);

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

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

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

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

/**
 * SetLayerVisibility represents the set layer visibility quickfix operation
 *
 * @generated from message artworking.v1.SetLayerVisibility
 */
export class SetLayerVisibility extends Message<SetLayerVisibility> {
  /**
   * @generated from field: repeated artworking.v1.SetLayerVisibilityInstruction instructions = 1;
   */
  instructions: SetLayerVisibilityInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.SetLayerVisibility";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: SetLayerVisibilityInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * SetPageBoxesInstruction represents a single set page boxes instruction
 *
 * @generated from message artworking.v1.SetPageBoxesInstruction
 */
export class SetPageBoxesInstruction extends Message<SetPageBoxesInstruction> {
  /**
   * Which pages
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

  /**
   * Target box: "CropBox", "BleedBox", "TrimBox", "ArtBox"
   *
   * @generated from field: string which_box = 2;
   */
  whichBox = "";

  /**
   * Reference box
   *
   * @generated from field: string from_box_or_absolute = 3;
   */
  fromBoxOrAbsolute = "";

  /**
   * Left position
   *
   * @generated from field: double left = 4;
   */
  left = 0;

  /**
   * Bottom position
   *
   * @generated from field: double bottom = 5;
   */
  bottom = 0;

  /**
   * Right position
   *
   * @generated from field: double right = 6;
   */
  right = 0;

  /**
   * Top position
   *
   * @generated from field: double top = 7;
   */
  top = 0;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.SetPageBoxesInstruction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "page_selector", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "which_box", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "from_box_or_absolute", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "left", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
    { no: 5, name: "bottom", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
    { no: 6, name: "right", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
    { no: 7, name: "top", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
    { no: 8, name: "unit", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * SetPageBoxes represents the set page boxes quickfix operation
 *
 * @generated from message artworking.v1.SetPageBoxes
 */
export class SetPageBoxes extends Message<SetPageBoxes> {
  /**
   * @generated from field: repeated artworking.v1.SetPageBoxesInstruction instructions = 1;
   */
  instructions: SetPageBoxesInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.SetPageBoxes";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: SetPageBoxesInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * SetPageGeometryOriginInstruction represents a single set page geometry origin instruction
 *
 * @generated from message artworking.v1.SetPageGeometryOriginInstruction
 */
export class SetPageGeometryOriginInstruction extends Message<SetPageGeometryOriginInstruction> {
  /**
   * Page range to set MediaBox origin: "all", etc.
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

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

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

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

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

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

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

/**
 * SetPageGeometryOrigin represents the set page geometry origin quickfix operation
 *
 * @generated from message artworking.v1.SetPageGeometryOrigin
 */
export class SetPageGeometryOrigin extends Message<SetPageGeometryOrigin> {
  /**
   * @generated from field: repeated artworking.v1.SetPageGeometryOriginInstruction instructions = 1;
   */
  instructions: SetPageGeometryOriginInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.SetPageGeometryOrigin";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: SetPageGeometryOriginInstruction, repeated: true },
  ]);

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

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

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

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

/**
 * SetPageRotationKeyInstruction represents a single set page rotation key instruction
 *
 * @generated from message artworking.v1.SetPageRotationKeyInstruction
 */
export class SetPageRotationKeyInstruction extends Message<SetPageRotationKeyInstruction> {
  /**
   * Page range to apply rotation: "all", "even", "odd", etc.
   *
   * @generated from field: string page_selector = 1;
   */
  pageSelector = "";

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

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

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

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

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

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

/**
 * SetPageRotationKey represents the set page rotation key quickfix operation
 *
 * @generated from message artworking.v1.SetPageRotationKey
 */
export class SetPageRotationKey extends Message<SetPageRotationKey> {
  /**
   * @generated from field: repeated artworking.v1.SetPageRotationKeyInstruction instructions = 1;
   */
  instructions: SetPageRotationKeyInstruction[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.SetPageRotationKey";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "instructions", kind: "message", T: SetPageRotationKeyInstruction, repeated: true },
  ]);

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

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

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

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