



#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace Rpcscanning {

  
  public static partial class RpcscannerReflection {

    #region Descriptor
    
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;

    static RpcscannerReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "ChBycGNzY2FubmVyLnByb3RvEgtycGNzY2FubmluZyIHCgVFbXB0eSIWCgRI",
            "d25kEg4KBmhhbmRsZRgBIAEoBSIjChBEb2N1bWVudHNTY2FubmVkEg8KB1Nj",
            "YW5uZWQYASABKAUiLQoFRXJyb3ISEQoJRXJyb3JDb2RlGAEgASgFEhEKCUVy",
            "cm9yVGV4dBgCIAEoCSKJAQoKUnBjTWVzc2FnZRIpCglFdmVudFR5cGUYASAB",
            "KA4yFi5ycGNzY2FubmluZy5FdmVudFR5cGUSJwoIRG9jdW1lbnQYAiABKAsy",
            "FS5ycGNzY2FubmluZy5Eb2N1bWVudBIUCgxFcnJvck1lc3NhZ2UYAyABKAkS",
            "EQoJRXJyb3JDb2RlGAQgASgFIoUBCghEb2N1bWVudBISCgpGcm9udEltYWdl",
            "GAEgASgMEhEKCUJhY2tJbWFnZRgCIAEoDBITCgtBcmVEZXNrZXdlZBgDIAEo",
            "CBIOCgZDYW5jZWwYBCABKAgSFgoORnJvbnRJbWFnZUhhc2gYBSABKAkSFQoN",
            "QmFja0ltYWdlSGFzaBgGIAEoCSJFChRTY2FubmVyQ29uZmlndXJhdGlvbhIZ",
            "ChFEcml2ZXJEZXNjcmlwdGlvbhgBIAEoCRISCgpDb25maWdGaWxlGAIgASgJ",
            "Ii8KEVNjYW5uZXJNb2RlbE5hbWVzEhoKEkRyaXZlckRlc2NyaXB0aW9ucxgB",
            "IAMoCSpDCglFdmVudFR5cGUSFgoSTmV3U2Nhbm5lZERvY3VtZW50EAASDwoL",
            "RmVlZGVyRW1wdHkQARINCglFeGNlcHRpb24QAjKdBAoKUnBjU2Nhbm5lchJM",
            "ChFJbml0aWFsaXplU2Nhbm5lchIhLnJwY3NjYW5uaW5nLlNjYW5uZXJDb25m",
            "aWd1cmF0aW9uGhIucnBjc2Nhbm5pbmcuRW1wdHkiABI3CgRTY2FuEhIucnBj",
            "c2Nhbm5pbmcuRW1wdHkaFy5ycGNzY2FubmluZy5ScGNNZXNzYWdlIgAwARI4",
            "CgxTdG9wU2Nhbm5pbmcSEi5ycGNzY2FubmluZy5FbXB0eRoSLnJwY3NjYW5u",
            "aW5nLkVtcHR5IgASOgoOUmVsZWFzZVNjYW5uZXISEi5ycGNzY2FubmluZy5F",
            "bXB0eRoSLnJwY3NjYW5uaW5nLkVtcHR5IgASOgoMQmF0Y2hBYm9ydGVkEhIu",
            "cnBjc2Nhbm5pbmcuRW1wdHkaEi5ycGNzY2FubmluZy5FbXB0eSIAMAESTAoU",
            "R2V0Q29ubmVjdGVkU2Nhbm5lcnMSEi5ycGNzY2FubmluZy5FbXB0eRoeLnJw",
            "Y3NjYW5uaW5nLlNjYW5uZXJNb2RlbE5hbWVzIgASTAoUR2V0SW5zdGFsbGVk",
            "U2Nhbm5lcnMSEi5ycGNzY2FubmluZy5FbXB0eRoeLnJwY3NjYW5uaW5nLlNj",
            "YW5uZXJNb2RlbE5hbWVzIgASOgoPQ29uZmlndXJlVmlhR3VpEhEucnBjc2Nh",
            "bm5pbmcuSHduZBoSLnJwY3NjYW5uaW5nLkVtcHR5IgBiBnByb3RvMw=="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { },
          new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Rpcscanning.EventType), }, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Rpcscanning.Empty), global::Rpcscanning.Empty.Parser, null, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Rpcscanning.Hwnd), global::Rpcscanning.Hwnd.Parser, new[]{ "Handle" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Rpcscanning.DocumentsScanned), global::Rpcscanning.DocumentsScanned.Parser, new[]{ "Scanned" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Rpcscanning.Error), global::Rpcscanning.Error.Parser, new[]{ "ErrorCode", "ErrorText" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Rpcscanning.RpcMessage), global::Rpcscanning.RpcMessage.Parser, new[]{ "EventType", "Document", "ErrorMessage", "ErrorCode" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Rpcscanning.Document), global::Rpcscanning.Document.Parser, new[]{ "FrontImage", "BackImage", "AreDeskewed", "Cancel", "FrontImageHash", "BackImageHash" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Rpcscanning.ScannerConfiguration), global::Rpcscanning.ScannerConfiguration.Parser, new[]{ "DriverDescription", "ConfigFile" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Rpcscanning.ScannerModelNames), global::Rpcscanning.ScannerModelNames.Parser, new[]{ "DriverDescriptions" }, null, null, null)
          }));
    }
    #endregion

  }
  #region Enums
  public enum EventType {
    [pbr::OriginalName("NewScannedDocument")] NewScannedDocument = 0,
    [pbr::OriginalName("FeederEmpty")] FeederEmpty = 1,
    [pbr::OriginalName("Exception")] Exception = 2,
  }

  #endregion

  #region Messages
  public sealed partial class Empty : pb::IMessage<Empty> {
    private static readonly pb::MessageParser<Empty> _parser = new pb::MessageParser<Empty>(() => new Empty());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<Empty> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Rpcscanning.RpcscannerReflection.Descriptor.MessageTypes[0]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Empty() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Empty(Empty other) : this() {
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Empty Clone() {
      return new Empty(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as Empty);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(Empty other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(Empty other) {
      if (other == null) {
        return;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
        }
      }
    }

  }

  public sealed partial class Hwnd : pb::IMessage<Hwnd> {
    private static readonly pb::MessageParser<Hwnd> _parser = new pb::MessageParser<Hwnd>(() => new Hwnd());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<Hwnd> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Rpcscanning.RpcscannerReflection.Descriptor.MessageTypes[1]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Hwnd() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Hwnd(Hwnd other) : this() {
      handle_ = other.handle_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Hwnd Clone() {
      return new Hwnd(this);
    }

    
    public const int HandleFieldNumber = 1;
    private int handle_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int Handle {
      get { return handle_; }
      set {
        handle_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as Hwnd);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(Hwnd other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Handle != other.Handle) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Handle != 0) hash ^= Handle.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Handle != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(Handle);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Handle != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Handle);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(Hwnd other) {
      if (other == null) {
        return;
      }
      if (other.Handle != 0) {
        Handle = other.Handle;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Handle = input.ReadInt32();
            break;
          }
        }
      }
    }

  }

  public sealed partial class DocumentsScanned : pb::IMessage<DocumentsScanned> {
    private static readonly pb::MessageParser<DocumentsScanned> _parser = new pb::MessageParser<DocumentsScanned>(() => new DocumentsScanned());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<DocumentsScanned> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Rpcscanning.RpcscannerReflection.Descriptor.MessageTypes[2]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public DocumentsScanned() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public DocumentsScanned(DocumentsScanned other) : this() {
      scanned_ = other.scanned_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public DocumentsScanned Clone() {
      return new DocumentsScanned(this);
    }

    
    public const int ScannedFieldNumber = 1;
    private int scanned_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int Scanned {
      get { return scanned_; }
      set {
        scanned_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as DocumentsScanned);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(DocumentsScanned other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Scanned != other.Scanned) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Scanned != 0) hash ^= Scanned.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Scanned != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(Scanned);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Scanned != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Scanned);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(DocumentsScanned other) {
      if (other == null) {
        return;
      }
      if (other.Scanned != 0) {
        Scanned = other.Scanned;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            Scanned = input.ReadInt32();
            break;
          }
        }
      }
    }

  }

  public sealed partial class Error : pb::IMessage<Error> {
    private static readonly pb::MessageParser<Error> _parser = new pb::MessageParser<Error>(() => new Error());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<Error> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Rpcscanning.RpcscannerReflection.Descriptor.MessageTypes[3]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Error() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Error(Error other) : this() {
      errorCode_ = other.errorCode_;
      errorText_ = other.errorText_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Error Clone() {
      return new Error(this);
    }

    
    public const int ErrorCodeFieldNumber = 1;
    private int errorCode_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int ErrorCode {
      get { return errorCode_; }
      set {
        errorCode_ = value;
      }
    }

    
    public const int ErrorTextFieldNumber = 2;
    private string errorText_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string ErrorText {
      get { return errorText_; }
      set {
        errorText_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as Error);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(Error other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (ErrorCode != other.ErrorCode) return false;
      if (ErrorText != other.ErrorText) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (ErrorCode != 0) hash ^= ErrorCode.GetHashCode();
      if (ErrorText.Length != 0) hash ^= ErrorText.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (ErrorCode != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(ErrorCode);
      }
      if (ErrorText.Length != 0) {
        output.WriteRawTag(18);
        output.WriteString(ErrorText);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (ErrorCode != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(ErrorCode);
      }
      if (ErrorText.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorText);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(Error other) {
      if (other == null) {
        return;
      }
      if (other.ErrorCode != 0) {
        ErrorCode = other.ErrorCode;
      }
      if (other.ErrorText.Length != 0) {
        ErrorText = other.ErrorText;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            ErrorCode = input.ReadInt32();
            break;
          }
          case 18: {
            ErrorText = input.ReadString();
            break;
          }
        }
      }
    }

  }

  public sealed partial class RpcMessage : pb::IMessage<RpcMessage> {
    private static readonly pb::MessageParser<RpcMessage> _parser = new pb::MessageParser<RpcMessage>(() => new RpcMessage());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<RpcMessage> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Rpcscanning.RpcscannerReflection.Descriptor.MessageTypes[4]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RpcMessage() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RpcMessage(RpcMessage other) : this() {
      eventType_ = other.eventType_;
      document_ = other.document_ != null ? other.document_.Clone() : null;
      errorMessage_ = other.errorMessage_;
      errorCode_ = other.errorCode_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public RpcMessage Clone() {
      return new RpcMessage(this);
    }

    
    public const int EventTypeFieldNumber = 1;
    private global::Rpcscanning.EventType eventType_ = 0;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Rpcscanning.EventType EventType {
      get { return eventType_; }
      set {
        eventType_ = value;
      }
    }

    
    public const int DocumentFieldNumber = 2;
    private global::Rpcscanning.Document document_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Rpcscanning.Document Document {
      get { return document_; }
      set {
        document_ = value;
      }
    }

    
    public const int ErrorMessageFieldNumber = 3;
    private string errorMessage_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string ErrorMessage {
      get { return errorMessage_; }
      set {
        errorMessage_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    
    public const int ErrorCodeFieldNumber = 4;
    private int errorCode_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int ErrorCode {
      get { return errorCode_; }
      set {
        errorCode_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as RpcMessage);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(RpcMessage other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (EventType != other.EventType) return false;
      if (!object.Equals(Document, other.Document)) return false;
      if (ErrorMessage != other.ErrorMessage) return false;
      if (ErrorCode != other.ErrorCode) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (EventType != 0) hash ^= EventType.GetHashCode();
      if (document_ != null) hash ^= Document.GetHashCode();
      if (ErrorMessage.Length != 0) hash ^= ErrorMessage.GetHashCode();
      if (ErrorCode != 0) hash ^= ErrorCode.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (EventType != 0) {
        output.WriteRawTag(8);
        output.WriteEnum((int) EventType);
      }
      if (document_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(Document);
      }
      if (ErrorMessage.Length != 0) {
        output.WriteRawTag(26);
        output.WriteString(ErrorMessage);
      }
      if (ErrorCode != 0) {
        output.WriteRawTag(32);
        output.WriteInt32(ErrorCode);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (EventType != 0) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) EventType);
      }
      if (document_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Document);
      }
      if (ErrorMessage.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(ErrorMessage);
      }
      if (ErrorCode != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(ErrorCode);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(RpcMessage other) {
      if (other == null) {
        return;
      }
      if (other.EventType != 0) {
        EventType = other.EventType;
      }
      if (other.document_ != null) {
        if (document_ == null) {
          document_ = new global::Rpcscanning.Document();
        }
        Document.MergeFrom(other.Document);
      }
      if (other.ErrorMessage.Length != 0) {
        ErrorMessage = other.ErrorMessage;
      }
      if (other.ErrorCode != 0) {
        ErrorCode = other.ErrorCode;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            eventType_ = (global::Rpcscanning.EventType) input.ReadEnum();
            break;
          }
          case 18: {
            if (document_ == null) {
              document_ = new global::Rpcscanning.Document();
            }
            input.ReadMessage(document_);
            break;
          }
          case 26: {
            ErrorMessage = input.ReadString();
            break;
          }
          case 32: {
            ErrorCode = input.ReadInt32();
            break;
          }
        }
      }
    }

  }

  public sealed partial class Document : pb::IMessage<Document> {
    private static readonly pb::MessageParser<Document> _parser = new pb::MessageParser<Document>(() => new Document());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<Document> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Rpcscanning.RpcscannerReflection.Descriptor.MessageTypes[5]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Document() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Document(Document other) : this() {
      frontImage_ = other.frontImage_;
      backImage_ = other.backImage_;
      areDeskewed_ = other.areDeskewed_;
      cancel_ = other.cancel_;
      frontImageHash_ = other.frontImageHash_;
      backImageHash_ = other.backImageHash_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public Document Clone() {
      return new Document(this);
    }

    
    public const int FrontImageFieldNumber = 1;
    private pb::ByteString frontImage_ = pb::ByteString.Empty;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pb::ByteString FrontImage {
      get { return frontImage_; }
      set {
        frontImage_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    
    public const int BackImageFieldNumber = 2;
    private pb::ByteString backImage_ = pb::ByteString.Empty;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pb::ByteString BackImage {
      get { return backImage_; }
      set {
        backImage_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    
    public const int AreDeskewedFieldNumber = 3;
    private bool areDeskewed_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool AreDeskewed {
      get { return areDeskewed_; }
      set {
        areDeskewed_ = value;
      }
    }

    
    public const int CancelFieldNumber = 4;
    private bool cancel_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Cancel {
      get { return cancel_; }
      set {
        cancel_ = value;
      }
    }

    
    public const int FrontImageHashFieldNumber = 5;
    private string frontImageHash_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string FrontImageHash {
      get { return frontImageHash_; }
      set {
        frontImageHash_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    
    public const int BackImageHashFieldNumber = 6;
    private string backImageHash_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string BackImageHash {
      get { return backImageHash_; }
      set {
        backImageHash_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as Document);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(Document other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (FrontImage != other.FrontImage) return false;
      if (BackImage != other.BackImage) return false;
      if (AreDeskewed != other.AreDeskewed) return false;
      if (Cancel != other.Cancel) return false;
      if (FrontImageHash != other.FrontImageHash) return false;
      if (BackImageHash != other.BackImageHash) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (FrontImage.Length != 0) hash ^= FrontImage.GetHashCode();
      if (BackImage.Length != 0) hash ^= BackImage.GetHashCode();
      if (AreDeskewed != false) hash ^= AreDeskewed.GetHashCode();
      if (Cancel != false) hash ^= Cancel.GetHashCode();
      if (FrontImageHash.Length != 0) hash ^= FrontImageHash.GetHashCode();
      if (BackImageHash.Length != 0) hash ^= BackImageHash.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (FrontImage.Length != 0) {
        output.WriteRawTag(10);
        output.WriteBytes(FrontImage);
      }
      if (BackImage.Length != 0) {
        output.WriteRawTag(18);
        output.WriteBytes(BackImage);
      }
      if (AreDeskewed != false) {
        output.WriteRawTag(24);
        output.WriteBool(AreDeskewed);
      }
      if (Cancel != false) {
        output.WriteRawTag(32);
        output.WriteBool(Cancel);
      }
      if (FrontImageHash.Length != 0) {
        output.WriteRawTag(42);
        output.WriteString(FrontImageHash);
      }
      if (BackImageHash.Length != 0) {
        output.WriteRawTag(50);
        output.WriteString(BackImageHash);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (FrontImage.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeBytesSize(FrontImage);
      }
      if (BackImage.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeBytesSize(BackImage);
      }
      if (AreDeskewed != false) {
        size += 1 + 1;
      }
      if (Cancel != false) {
        size += 1 + 1;
      }
      if (FrontImageHash.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(FrontImageHash);
      }
      if (BackImageHash.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(BackImageHash);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(Document other) {
      if (other == null) {
        return;
      }
      if (other.FrontImage.Length != 0) {
        FrontImage = other.FrontImage;
      }
      if (other.BackImage.Length != 0) {
        BackImage = other.BackImage;
      }
      if (other.AreDeskewed != false) {
        AreDeskewed = other.AreDeskewed;
      }
      if (other.Cancel != false) {
        Cancel = other.Cancel;
      }
      if (other.FrontImageHash.Length != 0) {
        FrontImageHash = other.FrontImageHash;
      }
      if (other.BackImageHash.Length != 0) {
        BackImageHash = other.BackImageHash;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            FrontImage = input.ReadBytes();
            break;
          }
          case 18: {
            BackImage = input.ReadBytes();
            break;
          }
          case 24: {
            AreDeskewed = input.ReadBool();
            break;
          }
          case 32: {
            Cancel = input.ReadBool();
            break;
          }
          case 42: {
            FrontImageHash = input.ReadString();
            break;
          }
          case 50: {
            BackImageHash = input.ReadString();
            break;
          }
        }
      }
    }

  }

  public sealed partial class ScannerConfiguration : pb::IMessage<ScannerConfiguration> {
    private static readonly pb::MessageParser<ScannerConfiguration> _parser = new pb::MessageParser<ScannerConfiguration>(() => new ScannerConfiguration());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ScannerConfiguration> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Rpcscanning.RpcscannerReflection.Descriptor.MessageTypes[6]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ScannerConfiguration() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ScannerConfiguration(ScannerConfiguration other) : this() {
      driverDescription_ = other.driverDescription_;
      configFile_ = other.configFile_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ScannerConfiguration Clone() {
      return new ScannerConfiguration(this);
    }

    
    public const int DriverDescriptionFieldNumber = 1;
    private string driverDescription_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string DriverDescription {
      get { return driverDescription_; }
      set {
        driverDescription_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    
    public const int ConfigFileFieldNumber = 2;
    private string configFile_ = "";
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string ConfigFile {
      get { return configFile_; }
      set {
        configFile_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ScannerConfiguration);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ScannerConfiguration other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (DriverDescription != other.DriverDescription) return false;
      if (ConfigFile != other.ConfigFile) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (DriverDescription.Length != 0) hash ^= DriverDescription.GetHashCode();
      if (ConfigFile.Length != 0) hash ^= ConfigFile.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (DriverDescription.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(DriverDescription);
      }
      if (ConfigFile.Length != 0) {
        output.WriteRawTag(18);
        output.WriteString(ConfigFile);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (DriverDescription.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(DriverDescription);
      }
      if (ConfigFile.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(ConfigFile);
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ScannerConfiguration other) {
      if (other == null) {
        return;
      }
      if (other.DriverDescription.Length != 0) {
        DriverDescription = other.DriverDescription;
      }
      if (other.ConfigFile.Length != 0) {
        ConfigFile = other.ConfigFile;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            DriverDescription = input.ReadString();
            break;
          }
          case 18: {
            ConfigFile = input.ReadString();
            break;
          }
        }
      }
    }

  }

  public sealed partial class ScannerModelNames : pb::IMessage<ScannerModelNames> {
    private static readonly pb::MessageParser<ScannerModelNames> _parser = new pb::MessageParser<ScannerModelNames>(() => new ScannerModelNames());
    private pb::UnknownFieldSet _unknownFields;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<ScannerModelNames> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Rpcscanning.RpcscannerReflection.Descriptor.MessageTypes[7]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ScannerModelNames() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ScannerModelNames(ScannerModelNames other) : this() {
      driverDescriptions_ = other.driverDescriptions_.Clone();
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public ScannerModelNames Clone() {
      return new ScannerModelNames(this);
    }

    
    public const int DriverDescriptionsFieldNumber = 1;
    private static readonly pb::FieldCodec<string> _repeated_driverDescriptions_codec
        = pb::FieldCodec.ForString(10);
    private readonly pbc::RepeatedField<string> driverDescriptions_ = new pbc::RepeatedField<string>();
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<string> DriverDescriptions {
      get { return driverDescriptions_; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as ScannerModelNames);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(ScannerModelNames other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!driverDescriptions_.Equals(other.driverDescriptions_)) return false;
      return Equals(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= driverDescriptions_.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      driverDescriptions_.WriteTo(output, _repeated_driverDescriptions_codec);
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += driverDescriptions_.CalculateSize(_repeated_driverDescriptions_codec);
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(ScannerModelNames other) {
      if (other == null) {
        return;
      }
      driverDescriptions_.Add(other.driverDescriptions_);
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 10: {
            driverDescriptions_.AddEntriesFrom(input, _repeated_driverDescriptions_codec);
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code

