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

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

/**
 * DielineAnalyserParams contains no configuration - dieline analysis requires no parameters
 *
 * @generated from message artworking.v1.DielineAnalyserParams
 */
export class DielineAnalyserParams extends Message<DielineAnalyserParams> {
  constructor(data?: PartialMessage<DielineAnalyserParams>) {
    super();
    proto3.util.initPartial(data, this);
  }

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

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

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

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

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

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

  /**
   * Optional: defaults to 2 seconds if not provided
   *
   * @generated from field: int32 poll_interval_seconds = 2;
   */
  pollIntervalSeconds = 0;

  /**
   * Optional: defaults to 300 seconds (5 minutes) if not provided
   *
   * @generated from field: int32 timeout_seconds = 3;
   */
  timeoutSeconds = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.StartDielineAnalyserRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "media_item_id", kind: "scalar", T: 3 /* ScalarType.INT64 */ },
    { no: 2, name: "poll_interval_seconds", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
    { no: 3, name: "timeout_seconds", kind: "scalar", T: 5 /* ScalarType.INT32 */ },
  ]);

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

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

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

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

/**
 * DielineSignature represents the styling and location information for a dieline element
 *
 * @generated from message artworking.v1.DielineSignature
 */
export class DielineSignature extends Message<DielineSignature> {
  /**
   * @generated from field: string element_name = 1;
   */
  elementName = "";

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

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

  /**
   * @generated from field: double stroke_width = 4;
   */
  strokeWidth = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.DielineSignature";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "element_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "layer_name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "stroke_color", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "stroke_width", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
  ]);

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

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

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

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

/**
 * DielineElement represents a single path element in a dieline group
 *
 * @generated from message artworking.v1.DielineElement
 */
export class DielineElement extends Message<DielineElement> {
  /**
   * @generated from field: string id = 1;
   */
  id = "";

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

  /**
   * @generated from field: artworking.v1.DielineSignature signature = 3;
   */
  signature?: DielineSignature;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.DielineElement";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "id", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "path_data", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "signature", kind: "message", T: DielineSignature },
    { no: 4, name: "type", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

/**
 * DielineGroup represents a collection of related dieline elements
 *
 * @generated from message artworking.v1.DielineGroup
 */
export class DielineGroup extends Message<DielineGroup> {
  /**
   * @generated from field: double count = 1;
   */
  count = 0;

  /**
   * repeated DielineElement elements = 2;
   *
   * @generated from field: string key = 3;
   */
  key = "";

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

  /**
   * @generated from field: artworking.v1.DielineSignature signature = 5;
   */
  signature?: DielineSignature;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.DielineGroup";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "count", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
    { no: 3, name: "key", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "label", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "signature", kind: "message", T: DielineSignature },
  ]);

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

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

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

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

/**
 * DielineMetadata contains summary statistics about the dieline analysis
 *
 * @generated from message artworking.v1.DielineMetadata
 */
export class DielineMetadata extends Message<DielineMetadata> {
  /**
   * @generated from field: double average_elements_per_group = 1;
   */
  averageElementsPerGroup = 0;

  /**
   * @generated from field: double total_groups = 2;
   */
  totalGroups = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.DielineMetadata";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "average_elements_per_group", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
    { no: 2, name: "total_groups", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
  ]);

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

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

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

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

/**
 * DielineAnalysisResult contains the complete dieline analysis results
 *
 * @generated from message artworking.v1.DielineAnalysisResult
 */
export class DielineAnalysisResult extends Message<DielineAnalysisResult> {
  /**
   * @generated from field: repeated artworking.v1.DielineGroup groups = 1;
   */
  groups: DielineGroup[] = [];

  /**
   * @generated from field: artworking.v1.DielineMetadata metadata = 2;
   */
  metadata?: DielineMetadata;

  /**
   * @generated from field: double total_elements = 3;
   */
  totalElements = 0;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.DielineAnalysisResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "groups", kind: "message", T: DielineGroup, repeated: true },
    { no: 2, name: "metadata", kind: "message", T: DielineMetadata },
    { no: 3, name: "total_elements", kind: "scalar", T: 1 /* ScalarType.DOUBLE */ },
  ]);

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

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

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

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

/**
 * @generated from message artworking.v1.StartDielineAnalyserResponse
 */
export class StartDielineAnalyserResponse extends Message<StartDielineAnalyserResponse> {
  /**
   * The structured dieline analysis results
   *
   * @generated from field: artworking.v1.DielineAnalysisResult analysis_result = 1;
   */
  analysisResult?: DielineAnalysisResult;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "artworking.v1.StartDielineAnalyserResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "analysis_result", kind: "message", T: DielineAnalysisResult },
  ]);

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

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

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

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