﻿// Generated by ProtoGen, Version=2.4.1.521, Culture=neutral, PublicKeyToken=17b3b1f090c3ea48.  DO NOT EDIT!
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;

namespace proto
{

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public static partial class Message
    {

        #region Extension registration
        public static void RegisterAllExtensions(pb::ExtensionRegistry registry)
        {
            registry.Add(global::proto.ColorRequest.ColorRequest_);
            registry.Add(global::proto.ImageRequest.ImageRequest_);
            registry.Add(global::proto.ClearRequest.ClearRequest_);
        }
        #endregion
        #region Static variables
        internal static pbd::MessageDescriptor internal__static_proto_HyperionRequest__Descriptor;
        internal static pb::FieldAccess.FieldAccessorTable<global::proto.HyperionRequest, global::proto.HyperionRequest.Builder> internal__static_proto_HyperionRequest__FieldAccessorTable;
        internal static pbd::MessageDescriptor internal__static_proto_ColorRequest__Descriptor;
        internal static pb::FieldAccess.FieldAccessorTable<global::proto.ColorRequest, global::proto.ColorRequest.Builder> internal__static_proto_ColorRequest__FieldAccessorTable;
        internal static pbd::MessageDescriptor internal__static_proto_ImageRequest__Descriptor;
        internal static pb::FieldAccess.FieldAccessorTable<global::proto.ImageRequest, global::proto.ImageRequest.Builder> internal__static_proto_ImageRequest__FieldAccessorTable;
        internal static pbd::MessageDescriptor internal__static_proto_ClearRequest__Descriptor;
        internal static pb::FieldAccess.FieldAccessorTable<global::proto.ClearRequest, global::proto.ClearRequest.Builder> internal__static_proto_ClearRequest__FieldAccessorTable;
        internal static pbd::MessageDescriptor internal__static_proto_HyperionReply__Descriptor;
        internal static pb::FieldAccess.FieldAccessorTable<global::proto.HyperionReply, global::proto.HyperionReply.Builder> internal__static_proto_HyperionReply__FieldAccessorTable;
        #endregion
        #region Descriptor
        public static pbd::FileDescriptor Descriptor
        {
            get { return descriptor; }
        }
        public static pbd::FileDescriptor descriptor;

        static Message()
        {
            var descriptorData = global::System.Convert.FromBase64String(
                "Cg1tZXNzYWdlLnByb3RvEgVwcm90byKCAQoPSHlwZXJpb25SZXF1ZXN0Ei8K" +
                "B2NvbW1hbmQYASACKA4yHi5wcm90by5IeXBlcmlvblJlcXVlc3QuQ29tbWFu" +
                "ZCI4CgdDb21tYW5kEgkKBUNPTE9SEAESCQoFSU1BR0UQAhIJCgVDTEVBUhAD" +
                "EgwKCENMRUFSQUxMEAQqBAgKEGUihwEKDENvbG9yUmVxdWVzdBIQCghwcmlv" +
                "cml0eRgBIAIoBRIQCghSZ2JDb2xvchgCIAIoBRIQCghkdXJhdGlvbhgDIAEo" +
                "BTJBCgxjb2xvclJlcXVlc3QSFi5wcm90by5IeXBlcmlvblJlcXVlc3QYCiAB" +
                "KAsyEy5wcm90by5Db2xvclJlcXVlc3QisQEKDEltYWdlUmVxdWVzdBIQCghw" +
                "cmlvcml0eRgBIAIoBRISCgppbWFnZXdpZHRoGAIgAigFEhMKC2ltYWdlaGVp" +
                "Z2h0GAMgAigFEhEKCWltYWdlZGF0YRgEIAIoDBIQCghkdXJhdGlvbhgFIAEo" +
                "BTJBCgxpbWFnZVJlcXVlc3QSFi5wcm90by5IeXBlcmlvblJlcXVlc3QYCyAB" +
                "KAsyEy5wcm90by5JbWFnZVJlcXVlc3QiYwoMQ2xlYXJSZXF1ZXN0EhAKCHBy" +
                "aW9yaXR5GAEgAigFMkEKDGNsZWFyUmVxdWVzdBIWLnByb3RvLkh5cGVyaW9u" +
                "UmVxdWVzdBgMIAEoCzITLnByb3RvLkNsZWFyUmVxdWVzdCIvCg1IeXBlcmlv" +
                "blJlcGx5Eg8KB3N1Y2Nlc3MYASACKAgSDQoFZXJyb3IYAiABKAk=");
            pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate (pbd::FileDescriptor root)
            {
                descriptor = root;
                internal__static_proto_HyperionRequest__Descriptor = Descriptor.MessageTypes[0];
                internal__static_proto_HyperionRequest__FieldAccessorTable =
                    new pb::FieldAccess.FieldAccessorTable<global::proto.HyperionRequest, global::proto.HyperionRequest.Builder>(internal__static_proto_HyperionRequest__Descriptor,
                        new string[] { "Command", });
                internal__static_proto_ColorRequest__Descriptor = Descriptor.MessageTypes[1];
                internal__static_proto_ColorRequest__FieldAccessorTable =
                    new pb::FieldAccess.FieldAccessorTable<global::proto.ColorRequest, global::proto.ColorRequest.Builder>(internal__static_proto_ColorRequest__Descriptor,
                        new string[] { "Priority", "RgbColor", "Duration", });
                global::proto.ColorRequest.ColorRequest_ = pb::GeneratedSingleExtension<global::proto.ColorRequest>.CreateInstance(global::proto.ColorRequest.Descriptor.Extensions[0]);
                internal__static_proto_ImageRequest__Descriptor = Descriptor.MessageTypes[2];
                internal__static_proto_ImageRequest__FieldAccessorTable =
                    new pb::FieldAccess.FieldAccessorTable<global::proto.ImageRequest, global::proto.ImageRequest.Builder>(internal__static_proto_ImageRequest__Descriptor,
                        new string[] { "Priority", "Imagewidth", "Imageheight", "Imagedata", "Duration", });
                global::proto.ImageRequest.ImageRequest_ = pb::GeneratedSingleExtension<global::proto.ImageRequest>.CreateInstance(global::proto.ImageRequest.Descriptor.Extensions[0]);
                internal__static_proto_ClearRequest__Descriptor = Descriptor.MessageTypes[3];
                internal__static_proto_ClearRequest__FieldAccessorTable =
                    new pb::FieldAccess.FieldAccessorTable<global::proto.ClearRequest, global::proto.ClearRequest.Builder>(internal__static_proto_ClearRequest__Descriptor,
                        new string[] { "Priority", });
                global::proto.ClearRequest.ClearRequest_ = pb::GeneratedSingleExtension<global::proto.ClearRequest>.CreateInstance(global::proto.ClearRequest.Descriptor.Extensions[0]);
                internal__static_proto_HyperionReply__Descriptor = Descriptor.MessageTypes[4];
                internal__static_proto_HyperionReply__FieldAccessorTable =
                    new pb::FieldAccess.FieldAccessorTable<global::proto.HyperionReply, global::proto.HyperionReply.Builder>(internal__static_proto_HyperionReply__Descriptor,
                        new string[] { "Success", "Error", });
                return null;
            };
            pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
                new pbd::FileDescriptor[] {
          }, assigner);
        }
        #endregion

    }
    #region Messages
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class HyperionRequest : pb::ExtendableMessage<HyperionRequest, HyperionRequest.Builder>
    {
        public HyperionRequest() { }
        public static readonly HyperionRequest defaultInstance = new HyperionRequest().MakeReadOnly();
        public static readonly string[] _hyperionRequestFieldNames = new string[] { "command" };
        public static readonly uint[] _hyperionRequestFieldTags = new uint[] { 8 };
        public static HyperionRequest DefaultInstance
        {
            get { return defaultInstance; }
        }

        public override HyperionRequest DefaultInstanceForType
        {
            get { return DefaultInstance; }
        }

        protected override HyperionRequest ThisMessage
        {
            get { return this; }
        }

        public static pbd::MessageDescriptor Descriptor
        {
            get { return global::proto.Message.internal__static_proto_HyperionRequest__Descriptor; }
        }

        protected override pb::FieldAccess.FieldAccessorTable<HyperionRequest, HyperionRequest.Builder> InternalFieldAccessors
        {
            get { return global::proto.Message.internal__static_proto_HyperionRequest__FieldAccessorTable; }
        }

        #region Nested types
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public static partial class Types
        {
            public enum Command
            {
                COLOR = 1,
                IMAGE = 2,
                CLEAR = 3,
                CLEARALL = 4,
            }

        }
        #endregion

        public const int CommandFieldNumber = 1;
        public bool hasCommand;
        public global::proto.HyperionRequest.Types.Command command_ = global::proto.HyperionRequest.Types.Command.COLOR;
        public bool HasCommand
        {
            get { return hasCommand; }
        }
        public global::proto.HyperionRequest.Types.Command Command
        {
            get { return command_; }
        }

        public override bool IsInitialized
        {
            get
            {
                if (!hasCommand) return false;
                if (!ExtensionsAreInitialized) return false;
                return true;
            }
        }

        public override void WriteTo(pb::ICodedOutputStream output)
        {
            var size = SerializedSize;
            var field_names = _hyperionRequestFieldNames;
            var extensionWriter = CreateExtensionWriter(this);
            if (hasCommand)
            {
                output.WriteEnum(1, field_names[0], (int)Command, Command);
            }
            extensionWriter.WriteUntil(101, output);
            UnknownFields.WriteTo(output);
        }

        public int memoizedSerializedSize = -1;
        public override int SerializedSize
        {
            get
            {
                var size = memoizedSerializedSize;
                if (size != -1) return size;

                size = 0;
                if (hasCommand)
                {
                    size += pb::CodedOutputStream.ComputeEnumSize(1, (int)Command);
                }
                size += ExtensionsSerializedSize;
                size += UnknownFields.SerializedSize;
                memoizedSerializedSize = size;
                return size;
            }
        }

        public static HyperionRequest ParseFrom(pb::ByteString data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static HyperionRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static HyperionRequest ParseFrom(byte[] data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static HyperionRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static HyperionRequest ParseFrom(global::System.IO.Stream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static HyperionRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static HyperionRequest ParseDelimitedFrom(global::System.IO.Stream input)
        {
            return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static HyperionRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static HyperionRequest ParseFrom(pb::ICodedInputStream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static HyperionRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public HyperionRequest MakeReadOnly()
        {
            return this;
        }

        public static Builder CreateBuilder() { return new Builder(); }
        public override Builder ToBuilder() { return CreateBuilder(this); }
        public override Builder CreateBuilderForType() { return new Builder(); }
        public static Builder CreateBuilder(HyperionRequest prototype)
        {
            return new Builder(prototype);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public sealed partial class Builder : pb::ExtendableBuilder<HyperionRequest, Builder>
        {
            protected override Builder ThisBuilder
            {
                get { return this; }
            }
            public Builder()
            {
                result = DefaultInstance;
                resultIsReadOnly = true;
            }
            internal Builder(HyperionRequest cloneFrom)
            {
                result = cloneFrom;
                resultIsReadOnly = true;
            }

            public bool resultIsReadOnly;
            public HyperionRequest result;

            public HyperionRequest PrepareBuilder()
            {
                if (resultIsReadOnly)
                {
                    var original = result;
                    result = new HyperionRequest();
                    resultIsReadOnly = false;
                    MergeFrom(original);
                }
                return result;
            }

            public override bool IsInitialized
            {
                get { return result.IsInitialized; }
            }

            protected override HyperionRequest MessageBeingBuilt
            {
                get { return PrepareBuilder(); }
            }

            public override Builder Clear()
            {
                result = DefaultInstance;
                resultIsReadOnly = true;
                return this;
            }

            public override Builder Clone()
            {
                if (resultIsReadOnly)
                {
                    return new Builder(result);
                }
                else
                {
                    return new Builder().MergeFrom(result);
                }
            }

            public override pbd::MessageDescriptor DescriptorForType
            {
                get { return Descriptor; }
            }

            public override HyperionRequest DefaultInstanceForType
            {
                get { return DefaultInstance; }
            }

            public override HyperionRequest BuildPartial()
            {
                if (resultIsReadOnly)
                {
                    return result;
                }
                resultIsReadOnly = true;
                return result.MakeReadOnly();
            }

            public override Builder MergeFrom(pb::IMessage other)
            {
                if (other is HyperionRequest)
                {
                    return MergeFrom((HyperionRequest)other);
                }
                else
                {
                    base.MergeFrom(other);
                    return this;
                }
            }

            public override Builder MergeFrom(HyperionRequest other)
            {
                if (other == DefaultInstance) return this;
                PrepareBuilder();
                if (other.HasCommand)
                {
                    Command = other.Command;
                }
                this.MergeExtensionFields(other);
                this.MergeUnknownFields(other.UnknownFields);
                return this;
            }

            public override Builder MergeFrom(pb::ICodedInputStream input)
            {
                return MergeFrom(input, pb::ExtensionRegistry.Empty);
            }

            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                PrepareBuilder();
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint tag;
                string field_name;
                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        var field_ordinal = global::System.Array.BinarySearch(_hyperionRequestFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                            tag = _hyperionRequestFieldTags[field_ordinal];
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                        case 0:
                            {
                                throw pb::InvalidProtocolBufferException.InvalidTag();
                            }
                        default:
                            {
                                if (pb::WireFormat.IsEndGroupTag(tag))
                                {
                                    if (unknownFields != null)
                                    {
                                        this.UnknownFields = unknownFields.Build();
                                    }
                                    return this;
                                }
                                if (unknownFields == null)
                                {
                                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                                }
                                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                                break;
                            }
                        case 8:
                            {
                                object unknown;
                                if (input.ReadEnum(ref result.command_, out unknown))
                                {
                                    result.hasCommand = true;
                                }
                                else if (unknown is int)
                                {
                                    if (unknownFields == null)
                                    {
                                        unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                                    }
                                    unknownFields.MergeVarintField(1, (ulong)(int)unknown);
                                }
                                break;
                            }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return this;
            }


            public bool HasCommand
            {
                get { return result.hasCommand; }
            }
            public global::proto.HyperionRequest.Types.Command Command
            {
                get { return result.Command; }
                set { SetCommand(value); }
            }
            public Builder SetCommand(global::proto.HyperionRequest.Types.Command value)
            {
                PrepareBuilder();
                result.hasCommand = true;
                result.command_ = value;
                return this;
            }
            public Builder ClearCommand()
            {
                PrepareBuilder();
                result.hasCommand = false;
                result.command_ = global::proto.HyperionRequest.Types.Command.COLOR;
                return this;
            }
        }
        static HyperionRequest()
        {
            ReferenceEquals(global::proto.Message.Descriptor, null);
        }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class ColorRequest : pb::GeneratedMessage<ColorRequest, ColorRequest.Builder>
    {
        public ColorRequest() { }
        public static readonly ColorRequest defaultInstance = new ColorRequest().MakeReadOnly();
        public static readonly string[] _colorRequestFieldNames = new string[] { "RgbColor", "duration", "priority" };
        public static readonly uint[] _colorRequestFieldTags = new uint[] { 16, 24, 8 };
        public static ColorRequest DefaultInstance
        {
            get { return defaultInstance; }
        }

        public override ColorRequest DefaultInstanceForType
        {
            get { return DefaultInstance; }
        }

        protected override ColorRequest ThisMessage
        {
            get { return this; }
        }

        public static pbd::MessageDescriptor Descriptor
        {
            get { return global::proto.Message.internal__static_proto_ColorRequest__Descriptor; }
        }

        protected override pb::FieldAccess.FieldAccessorTable<ColorRequest, ColorRequest.Builder> InternalFieldAccessors
        {
            get { return global::proto.Message.internal__static_proto_ColorRequest__FieldAccessorTable; }
        }

        public const int ColorRequestFieldNumber = 10;
        public static pb::GeneratedExtensionBase<global::proto.ColorRequest> ColorRequest_;
        public const int PriorityFieldNumber = 1;
        public bool hasPriority;
        public int priority_;
        public bool HasPriority
        {
            get { return hasPriority; }
        }
        public int Priority
        {
            get { return priority_; }
        }

        public const int RgbColorFieldNumber = 2;
        public bool hasRgbColor;
        public int rgbColor_;
        public bool HasRgbColor
        {
            get { return hasRgbColor; }
        }
        public int RgbColor
        {
            get { return rgbColor_; }
        }

        public const int DurationFieldNumber = 3;
        public bool hasDuration;
        public int duration_;
        public bool HasDuration
        {
            get { return hasDuration; }
        }
        public int Duration
        {
            get { return duration_; }
        }

        public override bool IsInitialized
        {
            get
            {
                if (!hasPriority) return false;
                if (!hasRgbColor) return false;
                return true;
            }
        }

        public override void WriteTo(pb::ICodedOutputStream output)
        {
            var size = SerializedSize;
            var field_names = _colorRequestFieldNames;
            if (hasPriority)
            {
                output.WriteInt32(1, field_names[2], Priority);
            }
            if (hasRgbColor)
            {
                output.WriteInt32(2, field_names[0], RgbColor);
            }
            if (hasDuration)
            {
                output.WriteInt32(3, field_names[1], Duration);
            }
            UnknownFields.WriteTo(output);
        }

        public int memoizedSerializedSize = -1;
        public override int SerializedSize
        {
            get
            {
                var size = memoizedSerializedSize;
                if (size != -1) return size;

                size = 0;
                if (hasPriority)
                {
                    size += pb::CodedOutputStream.ComputeInt32Size(1, Priority);
                }
                if (hasRgbColor)
                {
                    size += pb::CodedOutputStream.ComputeInt32Size(2, RgbColor);
                }
                if (hasDuration)
                {
                    size += pb::CodedOutputStream.ComputeInt32Size(3, Duration);
                }
                size += UnknownFields.SerializedSize;
                memoizedSerializedSize = size;
                return size;
            }
        }

        public static ColorRequest ParseFrom(pb::ByteString data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static ColorRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static ColorRequest ParseFrom(byte[] data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static ColorRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static ColorRequest ParseFrom(global::System.IO.Stream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static ColorRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static ColorRequest ParseDelimitedFrom(global::System.IO.Stream input)
        {
            return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static ColorRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static ColorRequest ParseFrom(pb::ICodedInputStream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static ColorRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public ColorRequest MakeReadOnly()
        {
            return this;
        }

        public static Builder CreateBuilder() { return new Builder(); }
        public override Builder ToBuilder() { return CreateBuilder(this); }
        public override Builder CreateBuilderForType() { return new Builder(); }
        public static Builder CreateBuilder(ColorRequest prototype)
        {
            return new Builder(prototype);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public sealed partial class Builder : pb::GeneratedBuilder<ColorRequest, Builder>
        {
            protected override Builder ThisBuilder
            {
                get { return this; }
            }
            public Builder()
            {
                result = DefaultInstance;
                resultIsReadOnly = true;
            }
            internal Builder(ColorRequest cloneFrom)
            {
                result = cloneFrom;
                resultIsReadOnly = true;
            }

            public bool resultIsReadOnly;
            public ColorRequest result;

            public ColorRequest PrepareBuilder()
            {
                if (resultIsReadOnly)
                {
                    var original = result;
                    result = new ColorRequest();
                    resultIsReadOnly = false;
                    MergeFrom(original);
                }
                return result;
            }

            public override bool IsInitialized
            {
                get { return result.IsInitialized; }
            }

            protected override ColorRequest MessageBeingBuilt
            {
                get { return PrepareBuilder(); }
            }

            public override Builder Clear()
            {
                result = DefaultInstance;
                resultIsReadOnly = true;
                return this;
            }

            public override Builder Clone()
            {
                if (resultIsReadOnly)
                {
                    return new Builder(result);
                }
                else
                {
                    return new Builder().MergeFrom(result);
                }
            }

            public override pbd::MessageDescriptor DescriptorForType
            {
                get { return Descriptor; }
            }

            public override ColorRequest DefaultInstanceForType
            {
                get { return DefaultInstance; }
            }

            public override ColorRequest BuildPartial()
            {
                if (resultIsReadOnly)
                {
                    return result;
                }
                resultIsReadOnly = true;
                return result.MakeReadOnly();
            }

            public override Builder MergeFrom(pb::IMessage other)
            {
                if (other is ColorRequest)
                {
                    return MergeFrom((ColorRequest)other);
                }
                else
                {
                    base.MergeFrom(other);
                    return this;
                }
            }

            public override Builder MergeFrom(ColorRequest other)
            {
                if (other == DefaultInstance) return this;
                PrepareBuilder();
                if (other.HasPriority)
                {
                    Priority = other.Priority;
                }
                if (other.HasRgbColor)
                {
                    RgbColor = other.RgbColor;
                }
                if (other.HasDuration)
                {
                    Duration = other.Duration;
                }
                this.MergeUnknownFields(other.UnknownFields);
                return this;
            }

            public override Builder MergeFrom(pb::ICodedInputStream input)
            {
                return MergeFrom(input, pb::ExtensionRegistry.Empty);
            }

            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                PrepareBuilder();
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint tag;
                string field_name;
                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        var field_ordinal = global::System.Array.BinarySearch(_colorRequestFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                            tag = _colorRequestFieldTags[field_ordinal];
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                        case 0:
                            {
                                throw pb::InvalidProtocolBufferException.InvalidTag();
                            }
                        default:
                            {
                                if (pb::WireFormat.IsEndGroupTag(tag))
                                {
                                    if (unknownFields != null)
                                    {
                                        this.UnknownFields = unknownFields.Build();
                                    }
                                    return this;
                                }
                                if (unknownFields == null)
                                {
                                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                                }
                                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                                break;
                            }
                        case 8:
                            {
                                result.hasPriority = input.ReadInt32(ref result.priority_);
                                break;
                            }
                        case 16:
                            {
                                result.hasRgbColor = input.ReadInt32(ref result.rgbColor_);
                                break;
                            }
                        case 24:
                            {
                                result.hasDuration = input.ReadInt32(ref result.duration_);
                                break;
                            }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return this;
            }


            public bool HasPriority
            {
                get { return result.hasPriority; }
            }
            public int Priority
            {
                get { return result.Priority; }
                set { SetPriority(value); }
            }
            public Builder SetPriority(int value)
            {
                PrepareBuilder();
                result.hasPriority = true;
                result.priority_ = value;
                return this;
            }
            public Builder ClearPriority()
            {
                PrepareBuilder();
                result.hasPriority = false;
                result.priority_ = 0;
                return this;
            }

            public bool HasRgbColor
            {
                get { return result.hasRgbColor; }
            }
            public int RgbColor
            {
                get { return result.RgbColor; }
                set { SetRgbColor(value); }
            }
            public Builder SetRgbColor(int value)
            {
                PrepareBuilder();
                result.hasRgbColor = true;
                result.rgbColor_ = value;
                return this;
            }
            public Builder ClearRgbColor()
            {
                PrepareBuilder();
                result.hasRgbColor = false;
                result.rgbColor_ = 0;
                return this;
            }

            public bool HasDuration
            {
                get { return result.hasDuration; }
            }
            public int Duration
            {
                get { return result.Duration; }
                set { SetDuration(value); }
            }
            public Builder SetDuration(int value)
            {
                PrepareBuilder();
                result.hasDuration = true;
                result.duration_ = value;
                return this;
            }
            public Builder ClearDuration()
            {
                PrepareBuilder();
                result.hasDuration = false;
                result.duration_ = 0;
                return this;
            }
        }
        static ColorRequest()
        {
            ReferenceEquals(global::proto.Message.Descriptor, null);
        }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class ImageRequest : pb::GeneratedMessage<ImageRequest, ImageRequest.Builder>
    {
        public ImageRequest() { }
        public static readonly ImageRequest defaultInstance = new ImageRequest().MakeReadOnly();
        public static readonly string[] _imageRequestFieldNames = new string[] { "duration", "imagedata", "imageheight", "imagewidth", "priority" };
        public static readonly uint[] _imageRequestFieldTags = new uint[] { 40, 34, 24, 16, 8 };
        public static ImageRequest DefaultInstance
        {
            get { return defaultInstance; }
        }

        public override ImageRequest DefaultInstanceForType
        {
            get { return DefaultInstance; }
        }

        protected override ImageRequest ThisMessage
        {
            get { return this; }
        }

        public static pbd::MessageDescriptor Descriptor
        {
            get { return global::proto.Message.internal__static_proto_ImageRequest__Descriptor; }
        }

        protected override pb::FieldAccess.FieldAccessorTable<ImageRequest, ImageRequest.Builder> InternalFieldAccessors
        {
            get { return global::proto.Message.internal__static_proto_ImageRequest__FieldAccessorTable; }
        }

        public const int ImageRequestFieldNumber = 11;
        public static pb::GeneratedExtensionBase<global::proto.ImageRequest> ImageRequest_;
        public const int PriorityFieldNumber = 1;
        public bool hasPriority;
        public int priority_;
        public bool HasPriority
        {
            get { return hasPriority; }
        }
        public int Priority
        {
            get { return priority_; }
        }

        public const int ImagewidthFieldNumber = 2;
        public bool hasImagewidth;
        public int imagewidth_;
        public bool HasImagewidth
        {
            get { return hasImagewidth; }
        }
        public int Imagewidth
        {
            get { return imagewidth_; }
        }

        public const int ImageheightFieldNumber = 3;
        public bool hasImageheight;
        public int imageheight_;
        public bool HasImageheight
        {
            get { return hasImageheight; }
        }
        public int Imageheight
        {
            get { return imageheight_; }
        }

        public const int ImagedataFieldNumber = 4;
        public bool hasImagedata;
        public pb::ByteString imagedata_ = pb::ByteString.Empty;
        public bool HasImagedata
        {
            get { return hasImagedata; }
        }
        public pb::ByteString Imagedata
        {
            get { return imagedata_; }
        }

        public const int DurationFieldNumber = 5;
        public bool hasDuration;
        public int duration_;
        public bool HasDuration
        {
            get { return hasDuration; }
        }
        public int Duration
        {
            get { return duration_; }
        }

        public override bool IsInitialized
        {
            get
            {
                if (!hasPriority) return false;
                if (!hasImagewidth) return false;
                if (!hasImageheight) return false;
                if (!hasImagedata) return false;
                return true;
            }
        }

        public override void WriteTo(pb::ICodedOutputStream output)
        {
            var size = SerializedSize;
            var field_names = _imageRequestFieldNames;
            if (hasPriority)
            {
                output.WriteInt32(1, field_names[4], Priority);
            }
            if (hasImagewidth)
            {
                output.WriteInt32(2, field_names[3], Imagewidth);
            }
            if (hasImageheight)
            {
                output.WriteInt32(3, field_names[2], Imageheight);
            }
            if (hasImagedata)
            {
                output.WriteBytes(4, field_names[1], Imagedata);
            }
            if (hasDuration)
            {
                output.WriteInt32(5, field_names[0], Duration);
            }
            UnknownFields.WriteTo(output);
        }

        public int memoizedSerializedSize = -1;
        public override int SerializedSize
        {
            get
            {
                var size = memoizedSerializedSize;
                if (size != -1) return size;

                size = 0;
                if (hasPriority)
                {
                    size += pb::CodedOutputStream.ComputeInt32Size(1, Priority);
                }
                if (hasImagewidth)
                {
                    size += pb::CodedOutputStream.ComputeInt32Size(2, Imagewidth);
                }
                if (hasImageheight)
                {
                    size += pb::CodedOutputStream.ComputeInt32Size(3, Imageheight);
                }
                if (hasImagedata)
                {
                    size += pb::CodedOutputStream.ComputeBytesSize(4, Imagedata);
                }
                if (hasDuration)
                {
                    size += pb::CodedOutputStream.ComputeInt32Size(5, Duration);
                }
                size += UnknownFields.SerializedSize;
                memoizedSerializedSize = size;
                return size;
            }
        }

        public static ImageRequest ParseFrom(pb::ByteString data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static ImageRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static ImageRequest ParseFrom(byte[] data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static ImageRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static ImageRequest ParseFrom(global::System.IO.Stream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static ImageRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static ImageRequest ParseDelimitedFrom(global::System.IO.Stream input)
        {
            return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static ImageRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static ImageRequest ParseFrom(pb::ICodedInputStream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static ImageRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public ImageRequest MakeReadOnly()
        {
            return this;
        }

        public static Builder CreateBuilder() { return new Builder(); }
        public override Builder ToBuilder() { return CreateBuilder(this); }
        public override Builder CreateBuilderForType() { return new Builder(); }
        public static Builder CreateBuilder(ImageRequest prototype)
        {
            return new Builder(prototype);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public sealed partial class Builder : pb::GeneratedBuilder<ImageRequest, Builder>
        {
            protected override Builder ThisBuilder
            {
                get { return this; }
            }
            public Builder()
            {
                result = DefaultInstance;
                resultIsReadOnly = true;
            }
            internal Builder(ImageRequest cloneFrom)
            {
                result = cloneFrom;
                resultIsReadOnly = true;
            }

            public bool resultIsReadOnly;
            public ImageRequest result;

            public ImageRequest PrepareBuilder()
            {
                if (resultIsReadOnly)
                {
                    var original = result;
                    result = new ImageRequest();
                    resultIsReadOnly = false;
                    MergeFrom(original);
                }
                return result;
            }

            public override bool IsInitialized
            {
                get { return result.IsInitialized; }
            }

            protected override ImageRequest MessageBeingBuilt
            {
                get { return PrepareBuilder(); }
            }

            public override Builder Clear()
            {
                result = DefaultInstance;
                resultIsReadOnly = true;
                return this;
            }

            public override Builder Clone()
            {
                if (resultIsReadOnly)
                {
                    return new Builder(result);
                }
                else
                {
                    return new Builder().MergeFrom(result);
                }
            }

            public override pbd::MessageDescriptor DescriptorForType
            {
                get { return Descriptor; }
            }

            public override ImageRequest DefaultInstanceForType
            {
                get { return DefaultInstance; }
            }

            public override ImageRequest BuildPartial()
            {
                if (resultIsReadOnly)
                {
                    return result;
                }
                resultIsReadOnly = true;
                return result.MakeReadOnly();
            }

            public override Builder MergeFrom(pb::IMessage other)
            {
                if (other is ImageRequest)
                {
                    return MergeFrom((ImageRequest)other);
                }
                else
                {
                    base.MergeFrom(other);
                    return this;
                }
            }

            public override Builder MergeFrom(ImageRequest other)
            {
                if (other == DefaultInstance) return this;
                PrepareBuilder();
                if (other.HasPriority)
                {
                    Priority = other.Priority;
                }
                if (other.HasImagewidth)
                {
                    Imagewidth = other.Imagewidth;
                }
                if (other.HasImageheight)
                {
                    Imageheight = other.Imageheight;
                }
                if (other.HasImagedata)
                {
                    Imagedata = other.Imagedata;
                }
                if (other.HasDuration)
                {
                    Duration = other.Duration;
                }
                this.MergeUnknownFields(other.UnknownFields);
                return this;
            }

            public override Builder MergeFrom(pb::ICodedInputStream input)
            {
                return MergeFrom(input, pb::ExtensionRegistry.Empty);
            }

            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                PrepareBuilder();
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint tag;
                string field_name;
                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        var field_ordinal = global::System.Array.BinarySearch(_imageRequestFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                            tag = _imageRequestFieldTags[field_ordinal];
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                        case 0:
                            {
                                throw pb::InvalidProtocolBufferException.InvalidTag();
                            }
                        default:
                            {
                                if (pb::WireFormat.IsEndGroupTag(tag))
                                {
                                    if (unknownFields != null)
                                    {
                                        this.UnknownFields = unknownFields.Build();
                                    }
                                    return this;
                                }
                                if (unknownFields == null)
                                {
                                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                                }
                                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                                break;
                            }
                        case 8:
                            {
                                result.hasPriority = input.ReadInt32(ref result.priority_);
                                break;
                            }
                        case 16:
                            {
                                result.hasImagewidth = input.ReadInt32(ref result.imagewidth_);
                                break;
                            }
                        case 24:
                            {
                                result.hasImageheight = input.ReadInt32(ref result.imageheight_);
                                break;
                            }
                        case 34:
                            {
                                result.hasImagedata = input.ReadBytes(ref result.imagedata_);
                                break;
                            }
                        case 40:
                            {
                                result.hasDuration = input.ReadInt32(ref result.duration_);
                                break;
                            }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return this;
            }


            public bool HasPriority
            {
                get { return result.hasPriority; }
            }
            public int Priority
            {
                get { return result.Priority; }
                set { SetPriority(value); }
            }
            public Builder SetPriority(int value)
            {
                PrepareBuilder();
                result.hasPriority = true;
                result.priority_ = value;
                return this;
            }
            public Builder ClearPriority()
            {
                PrepareBuilder();
                result.hasPriority = false;
                result.priority_ = 0;
                return this;
            }

            public bool HasImagewidth
            {
                get { return result.hasImagewidth; }
            }
            public int Imagewidth
            {
                get { return result.Imagewidth; }
                set { SetImagewidth(value); }
            }
            public Builder SetImagewidth(int value)
            {
                PrepareBuilder();
                result.hasImagewidth = true;
                result.imagewidth_ = value;
                return this;
            }
            public Builder ClearImagewidth()
            {
                PrepareBuilder();
                result.hasImagewidth = false;
                result.imagewidth_ = 0;
                return this;
            }

            public bool HasImageheight
            {
                get { return result.hasImageheight; }
            }
            public int Imageheight
            {
                get { return result.Imageheight; }
                set { SetImageheight(value); }
            }
            public Builder SetImageheight(int value)
            {
                PrepareBuilder();
                result.hasImageheight = true;
                result.imageheight_ = value;
                return this;
            }
            public Builder ClearImageheight()
            {
                PrepareBuilder();
                result.hasImageheight = false;
                result.imageheight_ = 0;
                return this;
            }

            public bool HasImagedata
            {
                get { return result.hasImagedata; }
            }
            public pb::ByteString Imagedata
            {
                get { return result.Imagedata; }
                set { SetImagedata(value); }
            }
            public Builder SetImagedata(pb::ByteString value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.hasImagedata = true;
                result.imagedata_ = value;
                return this;
            }
            public Builder ClearImagedata()
            {
                PrepareBuilder();
                result.hasImagedata = false;
                result.imagedata_ = pb::ByteString.Empty;
                return this;
            }

            public bool HasDuration
            {
                get { return result.hasDuration; }
            }
            public int Duration
            {
                get { return result.Duration; }
                set { SetDuration(value); }
            }
            public Builder SetDuration(int value)
            {
                PrepareBuilder();
                result.hasDuration = true;
                result.duration_ = value;
                return this;
            }
            public Builder ClearDuration()
            {
                PrepareBuilder();
                result.hasDuration = false;
                result.duration_ = 0;
                return this;
            }
        }
        static ImageRequest()
        {
            ReferenceEquals(global::proto.Message.Descriptor, null);
        }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class ClearRequest : pb::GeneratedMessage<ClearRequest, ClearRequest.Builder>
    {
        public ClearRequest() { }
        public static readonly ClearRequest defaultInstance = new ClearRequest().MakeReadOnly();
        public static readonly string[] _clearRequestFieldNames = new string[] { "priority" };
        public static readonly uint[] _clearRequestFieldTags = new uint[] { 8 };
        public static ClearRequest DefaultInstance
        {
            get { return defaultInstance; }
        }

        public override ClearRequest DefaultInstanceForType
        {
            get { return DefaultInstance; }
        }

        protected override ClearRequest ThisMessage
        {
            get { return this; }
        }

        public static pbd::MessageDescriptor Descriptor
        {
            get { return global::proto.Message.internal__static_proto_ClearRequest__Descriptor; }
        }

        protected override pb::FieldAccess.FieldAccessorTable<ClearRequest, ClearRequest.Builder> InternalFieldAccessors
        {
            get { return global::proto.Message.internal__static_proto_ClearRequest__FieldAccessorTable; }
        }

        public const int ClearRequestFieldNumber = 12;
        public static pb::GeneratedExtensionBase<global::proto.ClearRequest> ClearRequest_;
        public const int PriorityFieldNumber = 1;
        public bool hasPriority;
        public int priority_;
        public bool HasPriority
        {
            get { return hasPriority; }
        }
        public int Priority
        {
            get { return priority_; }
        }

        public override bool IsInitialized
        {
            get
            {
                if (!hasPriority) return false;
                return true;
            }
        }

        public override void WriteTo(pb::ICodedOutputStream output)
        {
            var size = SerializedSize;
            var field_names = _clearRequestFieldNames;
            if (hasPriority)
            {
                output.WriteInt32(1, field_names[0], Priority);
            }
            UnknownFields.WriteTo(output);
        }

        public int memoizedSerializedSize = -1;
        public override int SerializedSize
        {
            get
            {
                var size = memoizedSerializedSize;
                if (size != -1) return size;

                size = 0;
                if (hasPriority)
                {
                    size += pb::CodedOutputStream.ComputeInt32Size(1, Priority);
                }
                size += UnknownFields.SerializedSize;
                memoizedSerializedSize = size;
                return size;
            }
        }

        public static ClearRequest ParseFrom(pb::ByteString data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static ClearRequest ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static ClearRequest ParseFrom(byte[] data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static ClearRequest ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static ClearRequest ParseFrom(global::System.IO.Stream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static ClearRequest ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static ClearRequest ParseDelimitedFrom(global::System.IO.Stream input)
        {
            return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static ClearRequest ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static ClearRequest ParseFrom(pb::ICodedInputStream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static ClearRequest ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public ClearRequest MakeReadOnly()
        {
            return this;
        }

        public static Builder CreateBuilder() { return new Builder(); }
        public override Builder ToBuilder() { return CreateBuilder(this); }
        public override Builder CreateBuilderForType() { return new Builder(); }
        public static Builder CreateBuilder(ClearRequest prototype)
        {
            return new Builder(prototype);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public sealed partial class Builder : pb::GeneratedBuilder<ClearRequest, Builder>
        {
            protected override Builder ThisBuilder
            {
                get { return this; }
            }
            public Builder()
            {
                result = DefaultInstance;
                resultIsReadOnly = true;
            }
            internal Builder(ClearRequest cloneFrom)
            {
                result = cloneFrom;
                resultIsReadOnly = true;
            }

            public bool resultIsReadOnly;
            public ClearRequest result;

            public ClearRequest PrepareBuilder()
            {
                if (resultIsReadOnly)
                {
                    var original = result;
                    result = new ClearRequest();
                    resultIsReadOnly = false;
                    MergeFrom(original);
                }
                return result;
            }

            public override bool IsInitialized
            {
                get { return result.IsInitialized; }
            }

            protected override ClearRequest MessageBeingBuilt
            {
                get { return PrepareBuilder(); }
            }

            public override Builder Clear()
            {
                result = DefaultInstance;
                resultIsReadOnly = true;
                return this;
            }

            public override Builder Clone()
            {
                if (resultIsReadOnly)
                {
                    return new Builder(result);
                }
                else
                {
                    return new Builder().MergeFrom(result);
                }
            }

            public override pbd::MessageDescriptor DescriptorForType
            {
                get { return Descriptor; }
            }

            public override ClearRequest DefaultInstanceForType
            {
                get { return DefaultInstance; }
            }

            public override ClearRequest BuildPartial()
            {
                if (resultIsReadOnly)
                {
                    return result;
                }
                resultIsReadOnly = true;
                return result.MakeReadOnly();
            }

            public override Builder MergeFrom(pb::IMessage other)
            {
                if (other is ClearRequest)
                {
                    return MergeFrom((ClearRequest)other);
                }
                else
                {
                    base.MergeFrom(other);
                    return this;
                }
            }

            public override Builder MergeFrom(ClearRequest other)
            {
                if (other == DefaultInstance) return this;
                PrepareBuilder();
                if (other.HasPriority)
                {
                    Priority = other.Priority;
                }
                this.MergeUnknownFields(other.UnknownFields);
                return this;
            }

            public override Builder MergeFrom(pb::ICodedInputStream input)
            {
                return MergeFrom(input, pb::ExtensionRegistry.Empty);
            }

            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                PrepareBuilder();
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint tag;
                string field_name;
                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        var field_ordinal = global::System.Array.BinarySearch(_clearRequestFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                            tag = _clearRequestFieldTags[field_ordinal];
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                        case 0:
                            {
                                throw pb::InvalidProtocolBufferException.InvalidTag();
                            }
                        default:
                            {
                                if (pb::WireFormat.IsEndGroupTag(tag))
                                {
                                    if (unknownFields != null)
                                    {
                                        this.UnknownFields = unknownFields.Build();
                                    }
                                    return this;
                                }
                                if (unknownFields == null)
                                {
                                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                                }
                                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                                break;
                            }
                        case 8:
                            {
                                result.hasPriority = input.ReadInt32(ref result.priority_);
                                break;
                            }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return this;
            }


            public bool HasPriority
            {
                get { return result.hasPriority; }
            }
            public int Priority
            {
                get { return result.Priority; }
                set { SetPriority(value); }
            }
            public Builder SetPriority(int value)
            {
                PrepareBuilder();
                result.hasPriority = true;
                result.priority_ = value;
                return this;
            }
            public Builder ClearPriority()
            {
                PrepareBuilder();
                result.hasPriority = false;
                result.priority_ = 0;
                return this;
            }
        }
        static ClearRequest()
        {
            ReferenceEquals(global::proto.Message.Descriptor, null);
        }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class HyperionReply : pb::GeneratedMessage<HyperionReply, HyperionReply.Builder>
    {
        public HyperionReply() { }
        public static readonly HyperionReply defaultInstance = new HyperionReply().MakeReadOnly();
        public static readonly string[] _hyperionReplyFieldNames = new string[] { "error", "success" };
        public static readonly uint[] _hyperionReplyFieldTags = new uint[] { 18, 8 };
        public static HyperionReply DefaultInstance
        {
            get { return defaultInstance; }
        }

        public override HyperionReply DefaultInstanceForType
        {
            get { return DefaultInstance; }
        }

        protected override HyperionReply ThisMessage
        {
            get { return this; }
        }

        public static pbd::MessageDescriptor Descriptor
        {
            get { return global::proto.Message.internal__static_proto_HyperionReply__Descriptor; }
        }

        protected override pb::FieldAccess.FieldAccessorTable<HyperionReply, HyperionReply.Builder> InternalFieldAccessors
        {
            get { return global::proto.Message.internal__static_proto_HyperionReply__FieldAccessorTable; }
        }

        public const int SuccessFieldNumber = 1;
        public bool hasSuccess;
        public bool success_;
        public bool HasSuccess
        {
            get { return hasSuccess; }
        }
        public bool Success
        {
            get { return success_; }
        }

        public const int ErrorFieldNumber = 2;
        public bool hasError;
        public string error_ = "";
        public bool HasError
        {
            get { return hasError; }
        }
        public string Error
        {
            get { return error_; }
        }

        public override bool IsInitialized
        {
            get
            {
                if (!hasSuccess) return false;
                return true;
            }
        }

        public override void WriteTo(pb::ICodedOutputStream output)
        {
            var size = SerializedSize;
            var field_names = _hyperionReplyFieldNames;
            if (hasSuccess)
            {
                output.WriteBool(1, field_names[1], Success);
            }
            if (hasError)
            {
                output.WriteString(2, field_names[0], Error);
            }
            UnknownFields.WriteTo(output);
        }

        public int memoizedSerializedSize = -1;
        public override int SerializedSize
        {
            get
            {
                var size = memoizedSerializedSize;
                if (size != -1) return size;

                size = 0;
                if (hasSuccess)
                {
                    size += pb::CodedOutputStream.ComputeBoolSize(1, Success);
                }
                if (hasError)
                {
                    size += pb::CodedOutputStream.ComputeStringSize(2, Error);
                }
                size += UnknownFields.SerializedSize;
                memoizedSerializedSize = size;
                return size;
            }
        }

        public static HyperionReply ParseFrom(pb::ByteString data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static HyperionReply ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static HyperionReply ParseFrom(byte[] data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static HyperionReply ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static HyperionReply ParseFrom(global::System.IO.Stream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static HyperionReply ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static HyperionReply ParseDelimitedFrom(global::System.IO.Stream input)
        {
            return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static HyperionReply ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static HyperionReply ParseFrom(pb::ICodedInputStream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static HyperionReply ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public HyperionReply MakeReadOnly()
        {
            return this;
        }

        public static Builder CreateBuilder() { return new Builder(); }
        public override Builder ToBuilder() { return CreateBuilder(this); }
        public override Builder CreateBuilderForType() { return new Builder(); }
        public static Builder CreateBuilder(HyperionReply prototype)
        {
            return new Builder(prototype);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public sealed partial class Builder : pb::GeneratedBuilder<HyperionReply, Builder>
        {
            protected override Builder ThisBuilder
            {
                get { return this; }
            }
            public Builder()
            {
                result = DefaultInstance;
                resultIsReadOnly = true;
            }
            internal Builder(HyperionReply cloneFrom)
            {
                result = cloneFrom;
                resultIsReadOnly = true;
            }

            public bool resultIsReadOnly;
            public HyperionReply result;

            public HyperionReply PrepareBuilder()
            {
                if (resultIsReadOnly)
                {
                    var original = result;
                    result = new HyperionReply();
                    resultIsReadOnly = false;
                    MergeFrom(original);
                }
                return result;
            }

            public override bool IsInitialized
            {
                get { return result.IsInitialized; }
            }

            protected override HyperionReply MessageBeingBuilt
            {
                get { return PrepareBuilder(); }
            }

            public override Builder Clear()
            {
                result = DefaultInstance;
                resultIsReadOnly = true;
                return this;
            }

            public override Builder Clone()
            {
                if (resultIsReadOnly)
                {
                    return new Builder(result);
                }
                else
                {
                    return new Builder().MergeFrom(result);
                }
            }

            public override pbd::MessageDescriptor DescriptorForType
            {
                get { return Descriptor; }
            }

            public override HyperionReply DefaultInstanceForType
            {
                get { return DefaultInstance; }
            }

            public override HyperionReply BuildPartial()
            {
                if (resultIsReadOnly)
                {
                    return result;
                }
                resultIsReadOnly = true;
                return result.MakeReadOnly();
            }

            public override Builder MergeFrom(pb::IMessage other)
            {
                if (other is HyperionReply)
                {
                    return MergeFrom((HyperionReply)other);
                }
                else
                {
                    base.MergeFrom(other);
                    return this;
                }
            }

            public override Builder MergeFrom(HyperionReply other)
            {
                if (other == DefaultInstance) return this;
                PrepareBuilder();
                if (other.HasSuccess)
                {
                    Success = other.Success;
                }
                if (other.HasError)
                {
                    Error = other.Error;
                }
                this.MergeUnknownFields(other.UnknownFields);
                return this;
            }

            public override Builder MergeFrom(pb::ICodedInputStream input)
            {
                return MergeFrom(input, pb::ExtensionRegistry.Empty);
            }

            public override Builder MergeFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
            {
                PrepareBuilder();
                pb::UnknownFieldSet.Builder unknownFields = null;
                uint tag;
                string field_name;
                while (input.ReadTag(out tag, out field_name))
                {
                    if (tag == 0 && field_name != null)
                    {
                        var field_ordinal = global::System.Array.BinarySearch(_hyperionReplyFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                            tag = _hyperionReplyFieldTags[field_ordinal];
                        else
                        {
                            if (unknownFields == null)
                            {
                                unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                            }
                            ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                            continue;
                        }
                    }
                    switch (tag)
                    {
                        case 0:
                            {
                                throw pb::InvalidProtocolBufferException.InvalidTag();
                            }
                        default:
                            {
                                if (pb::WireFormat.IsEndGroupTag(tag))
                                {
                                    if (unknownFields != null)
                                    {
                                        this.UnknownFields = unknownFields.Build();
                                    }
                                    return this;
                                }
                                if (unknownFields == null)
                                {
                                    unknownFields = pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
                                }
                                ParseUnknownField(input, unknownFields, extensionRegistry, tag, field_name);
                                break;
                            }
                        case 8:
                            {
                                result.hasSuccess = input.ReadBool(ref result.success_);
                                break;
                            }
                        case 18:
                            {
                                result.hasError = input.ReadString(ref result.error_);
                                break;
                            }
                    }
                }

                if (unknownFields != null)
                {
                    this.UnknownFields = unknownFields.Build();
                }
                return this;
            }


            public bool HasSuccess
            {
                get { return result.hasSuccess; }
            }
            public bool Success
            {
                get { return result.Success; }
                set { SetSuccess(value); }
            }
            public Builder SetSuccess(bool value)
            {
                PrepareBuilder();
                result.hasSuccess = true;
                result.success_ = value;
                return this;
            }
            public Builder ClearSuccess()
            {
                PrepareBuilder();
                result.hasSuccess = false;
                result.success_ = false;
                return this;
            }

            public bool HasError
            {
                get { return result.hasError; }
            }
            public string Error
            {
                get { return result.Error; }
                set { SetError(value); }
            }
            public Builder SetError(string value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.hasError = true;
                result.error_ = value;
                return this;
            }
            public Builder ClearError()
            {
                PrepareBuilder();
                result.hasError = false;
                result.error_ = "";
                return this;
            }
        }
        static HyperionReply()
        {
            ReferenceEquals(global::proto.Message.Descriptor, null);
        }
    }

    #endregion

}

#endregion Designer generated code