// Generated by ProtoGen, Version=2.4.1.521, Culture=neutral, PublicKeyToken=55f7125234beb589.  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 Aliyun.Api.LOG
{

    namespace Proto
    {

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

            #region Extension registration
            public static void RegisterAllExtensions(pb::ExtensionRegistry registry)
            {
            }
            #endregion
            #region Static variables
            internal static pbd::MessageDescriptor internal__static_Log__Descriptor;
            internal static pb::FieldAccess.FieldAccessorTable<global::Aliyun.Api.LOG.Log, global::Aliyun.Api.LOG.Log.Builder> internal__static_Log__FieldAccessorTable;
            internal static pbd::MessageDescriptor internal__static_Log_Content__Descriptor;
            internal static pb::FieldAccess.FieldAccessorTable<global::Aliyun.Api.LOG.Log.Types.Content, global::Aliyun.Api.LOG.Log.Types.Content.Builder> internal__static_Log_Content__FieldAccessorTable;
            internal static pbd::MessageDescriptor internal__static_LogGroup__Descriptor;
            internal static pb::FieldAccess.FieldAccessorTable<global::Aliyun.Api.LOG.LogGroup, global::Aliyun.Api.LOG.LogGroup.Builder> internal__static_LogGroup__FieldAccessorTable;
            internal static pbd::MessageDescriptor internal__static_LogGroupList__Descriptor;
            internal static pb::FieldAccess.FieldAccessorTable<global::Aliyun.Api.LOG.LogGroupList, global::Aliyun.Api.LOG.LogGroupList.Builder> internal__static_LogGroupList__FieldAccessorTable;
            #endregion
            #region Descriptor
            public static pbd::FileDescriptor Descriptor
            {
                get { return descriptor; }
            }
            private static pbd::FileDescriptor descriptor;

            static LogGroup()
            {
                byte[] descriptorData = global::System.Convert.FromBase64String(
                    "Chd0dXRvcmlhbC9Mb2dHcm91cC5wcm90bxokZ29vZ2xlL3Byb3RvYnVmL2Nz" +
                    "aGFycF9vcHRpb25zLnByb3RvIloKA0xvZxIMCgRUaW1lGAEgAigNEh4KCENv" +
                    "bnRlbnRzGAIgAygLMgwuTG9nLkNvbnRlbnQaJQoHQ29udGVudBILCgNLZXkY" +
                    "ASACKAkSDQoFVmFsdWUYAiACKAkiTwoITG9nR3JvdXASEgoETG9ncxgBIAMo" +
                    "CzIELkxvZxIQCghSZXNlcnZlZBgCIAEoCRINCgVUb3BpYxgDIAEoCRIOCgZT" +
                    "b3VyY2UYBCABKAkiLwoMTG9nR3JvdXBMaXN0Eh8KDGxvZ0dyb3VwTGlzdBgB" +
                    "IAMoCzIJLkxvZ0dyb3VwQhPCPhAKDkFsaXl1bi5BcGkuTE9H");
                pbd::FileDescriptor.InternalDescriptorAssigner assigner = delegate(pbd::FileDescriptor root)
                {
                    descriptor = root;
                    internal__static_Log__Descriptor = Descriptor.MessageTypes[0];
                    internal__static_Log__FieldAccessorTable =
                        new pb::FieldAccess.FieldAccessorTable<global::Aliyun.Api.LOG.Log, global::Aliyun.Api.LOG.Log.Builder>(internal__static_Log__Descriptor,
                            new string[] { "Time", "Contents", });
                    internal__static_Log_Content__Descriptor = internal__static_Log__Descriptor.NestedTypes[0];
                    internal__static_Log_Content__FieldAccessorTable =
                        new pb::FieldAccess.FieldAccessorTable<global::Aliyun.Api.LOG.Log.Types.Content, global::Aliyun.Api.LOG.Log.Types.Content.Builder>(internal__static_Log_Content__Descriptor,
                            new string[] { "Key", "Value", });
                    internal__static_LogGroup__Descriptor = Descriptor.MessageTypes[1];
                    internal__static_LogGroup__FieldAccessorTable =
                        new pb::FieldAccess.FieldAccessorTable<global::Aliyun.Api.LOG.LogGroup, global::Aliyun.Api.LOG.LogGroup.Builder>(internal__static_LogGroup__Descriptor,
                            new string[] { "Logs", "Reserved", "Topic", "Source", });
                    internal__static_LogGroupList__Descriptor = Descriptor.MessageTypes[2];
                    internal__static_LogGroupList__FieldAccessorTable =
                        new pb::FieldAccess.FieldAccessorTable<global::Aliyun.Api.LOG.LogGroupList, global::Aliyun.Api.LOG.LogGroupList.Builder>(internal__static_LogGroupList__Descriptor,
                            new string[] { "LogGroupList_", });
                    pb::ExtensionRegistry registry = pb::ExtensionRegistry.CreateInstance();
                    RegisterAllExtensions(registry);
                    global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.RegisterAllExtensions(registry);
                    return registry;
                };
                pbd::FileDescriptor.InternalBuildGeneratedFileFrom(descriptorData,
                    new pbd::FileDescriptor[] {
            global::Google.ProtocolBuffers.DescriptorProtos.CSharpOptions.Descriptor, 
            }, assigner);
            }
            #endregion

        }
    }
    #region Messages
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class Log : pb::GeneratedMessage<Log, Log.Builder>
    {
        private Log() { }
        private static readonly Log defaultInstance = new Log().MakeReadOnly();
        private static readonly string[] _logFieldNames = new string[] { "Contents", "Time" };
        private static readonly uint[] _logFieldTags = new uint[] { 18, 8 };
        public static Log DefaultInstance
        {
            get { return defaultInstance; }
        }

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

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

        public static pbd::MessageDescriptor Descriptor
        {
            get { return global::Aliyun.Api.LOG.Proto.LogGroup.internal__static_Log__Descriptor; }
        }

        protected override pb::FieldAccess.FieldAccessorTable<Log, Log.Builder> InternalFieldAccessors
        {
            get { return global::Aliyun.Api.LOG.Proto.LogGroup.internal__static_Log__FieldAccessorTable; }
        }

        #region Nested types
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
        public static partial class Types
        {
            [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
            public sealed partial class Content : pb::GeneratedMessage<Content, Content.Builder>
            {
                private Content() { }
                private static readonly Content defaultInstance = new Content().MakeReadOnly();
                private static readonly string[] _contentFieldNames = new string[] { "Key", "Value" };
                private static readonly uint[] _contentFieldTags = new uint[] { 10, 18 };
                public static Content DefaultInstance
                {
                    get { return defaultInstance; }
                }

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

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

                public static pbd::MessageDescriptor Descriptor
                {
                    get { return global::Aliyun.Api.LOG.Proto.LogGroup.internal__static_Log_Content__Descriptor; }
                }

                protected override pb::FieldAccess.FieldAccessorTable<Content, Content.Builder> InternalFieldAccessors
                {
                    get { return global::Aliyun.Api.LOG.Proto.LogGroup.internal__static_Log_Content__FieldAccessorTable; }
                }

                public const int KeyFieldNumber = 1;
                private bool hasKey;
                private string key_ = "";
                public bool HasKey
                {
                    get { return hasKey; }
                }
                public string Key
                {
                    get { return key_; }
                }

                public const int ValueFieldNumber = 2;
                private bool hasValue;
                private string value_ = "";
                public bool HasValue
                {
                    get { return hasValue; }
                }
                public string Value
                {
                    get { return value_; }
                }

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

                public override void WriteTo(pb::ICodedOutputStream output)
                {
                    int size = SerializedSize;
                    string[] field_names = _contentFieldNames;
                    if (hasKey)
                    {
                        output.WriteString(1, field_names[0], Key);
                    }
                    if (hasValue)
                    {
                        output.WriteString(2, field_names[1], Value);
                    }
                    UnknownFields.WriteTo(output);
                }

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

                        size = 0;
                        if (hasKey)
                        {
                            size += pb::CodedOutputStream.ComputeStringSize(1, Key);
                        }
                        if (hasValue)
                        {
                            size += pb::CodedOutputStream.ComputeStringSize(2, Value);
                        }
                        size += UnknownFields.SerializedSize;
                        memoizedSerializedSize = size;
                        return size;
                    }
                }

                public static Content ParseFrom(pb::ByteString data)
                {
                    return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
                }
                public static Content ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
                {
                    return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
                }
                public static Content ParseFrom(byte[] data)
                {
                    return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
                }
                public static Content ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
                {
                    return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
                }
                public static Content ParseFrom(global::System.IO.Stream input)
                {
                    return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
                }
                public static Content ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
                {
                    return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
                }
                public static Content ParseDelimitedFrom(global::System.IO.Stream input)
                {
                    return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
                }
                public static Content ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
                {
                    return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
                }
                public static Content ParseFrom(pb::ICodedInputStream input)
                {
                    return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
                }
                public static Content ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
                {
                    return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
                }
                private Content 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(Content prototype)
                {
                    return new Builder(prototype);
                }

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

                    private bool resultIsReadOnly;
                    private Content result;

                    private Content PrepareBuilder()
                    {
                        if (resultIsReadOnly)
                        {
                            Content original = result;
                            result = new Content();
                            resultIsReadOnly = false;
                            MergeFrom(original);
                        }
                        return result;
                    }

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

                    protected override Content 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 global::Aliyun.Api.LOG.Log.Types.Content.Descriptor; }
                    }

                    public override Content DefaultInstanceForType
                    {
                        get { return global::Aliyun.Api.LOG.Log.Types.Content.DefaultInstance; }
                    }

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

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

                    public override Builder MergeFrom(Content other)
                    {
                        if (other == global::Aliyun.Api.LOG.Log.Types.Content.DefaultInstance) return this;
                        PrepareBuilder();
                        if (other.HasKey)
                        {
                            Key = other.Key;
                        }
                        if (other.HasValue)
                        {
                            Value = other.Value;
                        }
                        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)
                            {
                                int field_ordinal = global::System.Array.BinarySearch(_contentFieldNames, field_name, global::System.StringComparer.Ordinal);
                                if (field_ordinal >= 0)
                                    tag = _contentFieldTags[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 10:
                                    {
                                        result.hasKey = input.ReadString(ref result.key_);
                                        break;
                                    }
                                case 18:
                                    {
                                        result.hasValue = input.ReadString(ref result.value_);
                                        break;
                                    }
                            }
                        }

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


                    public bool HasKey
                    {
                        get { return result.hasKey; }
                    }
                    public string Key
                    {
                        get { return result.Key; }
                        set { SetKey(value); }
                    }
                    public Builder SetKey(string value)
                    {
                        pb::ThrowHelper.ThrowIfNull(value, "value");
                        PrepareBuilder();
                        result.hasKey = true;
                        result.key_ = value;
                        return this;
                    }
                    public Builder ClearKey()
                    {
                        PrepareBuilder();
                        result.hasKey = false;
                        result.key_ = "";
                        return this;
                    }

                    public bool HasValue
                    {
                        get { return result.hasValue; }
                    }
                    public string Value
                    {
                        get { return result.Value; }
                        set { SetValue(value); }
                    }
                    public Builder SetValue(string value)
                    {
                        pb::ThrowHelper.ThrowIfNull(value, "value");
                        PrepareBuilder();
                        result.hasValue = true;
                        result.value_ = value;
                        return this;
                    }
                    public Builder ClearValue()
                    {
                        PrepareBuilder();
                        result.hasValue = false;
                        result.value_ = "";
                        return this;
                    }
                }
                static Content()
                {
                    object.ReferenceEquals(global::Aliyun.Api.LOG.Proto.LogGroup.Descriptor, null);
                }
            }

        }
        #endregion

        public const int TimeFieldNumber = 1;
        private bool hasTime;
        private uint time_;
        public bool HasTime
        {
            get { return hasTime; }
        }
        [global::System.CLSCompliant(false)]
        public uint Time
        {
            get { return time_; }
        }

        public const int ContentsFieldNumber = 2;
        private pbc::PopsicleList<global::Aliyun.Api.LOG.Log.Types.Content> contents_ = new pbc::PopsicleList<global::Aliyun.Api.LOG.Log.Types.Content>();
        public scg::IList<global::Aliyun.Api.LOG.Log.Types.Content> ContentsList
        {
            get { return contents_; }
        }
        public int ContentsCount
        {
            get { return contents_.Count; }
        }
        public global::Aliyun.Api.LOG.Log.Types.Content GetContents(int index)
        {
            return contents_[index];
        }

        public override bool IsInitialized
        {
            get
            {
                if (!hasTime) return false;
                foreach (global::Aliyun.Api.LOG.Log.Types.Content element in ContentsList)
                {
                    if (!element.IsInitialized) return false;
                }
                return true;
            }
        }

        public override void WriteTo(pb::ICodedOutputStream output)
        {
            int size = SerializedSize;
            string[] field_names = _logFieldNames;
            if (hasTime)
            {
                output.WriteUInt32(1, field_names[1], Time);
            }
            if (contents_.Count > 0)
            {
                output.WriteMessageArray(2, field_names[0], contents_);
            }
            UnknownFields.WriteTo(output);
        }

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

                size = 0;
                if (hasTime)
                {
                    size += pb::CodedOutputStream.ComputeUInt32Size(1, Time);
                }
                foreach (global::Aliyun.Api.LOG.Log.Types.Content element in ContentsList)
                {
                    size += pb::CodedOutputStream.ComputeMessageSize(2, element);
                }
                size += UnknownFields.SerializedSize;
                memoizedSerializedSize = size;
                return size;
            }
        }

        public static Log ParseFrom(pb::ByteString data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static Log ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static Log ParseFrom(byte[] data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static Log ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static Log ParseFrom(global::System.IO.Stream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static Log ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static Log ParseDelimitedFrom(global::System.IO.Stream input)
        {
            return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static Log ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static Log ParseFrom(pb::ICodedInputStream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static Log ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        private Log MakeReadOnly()
        {
            contents_.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(Log prototype)
        {
            return new Builder(prototype);
        }

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

            private bool resultIsReadOnly;
            private Log result;

            private Log PrepareBuilder()
            {
                if (resultIsReadOnly)
                {
                    Log original = result;
                    result = new Log();
                    resultIsReadOnly = false;
                    MergeFrom(original);
                }
                return result;
            }

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

            protected override Log 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 global::Aliyun.Api.LOG.Log.Descriptor; }
            }

            public override Log DefaultInstanceForType
            {
                get { return global::Aliyun.Api.LOG.Log.DefaultInstance; }
            }

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

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

            public override Builder MergeFrom(Log other)
            {
                if (other == global::Aliyun.Api.LOG.Log.DefaultInstance) return this;
                PrepareBuilder();
                if (other.HasTime)
                {
                    Time = other.Time;
                }
                if (other.contents_.Count != 0)
                {
                    result.contents_.Add(other.contents_);
                }
                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)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_logFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                            tag = _logFieldTags[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.hasTime = input.ReadUInt32(ref result.time_);
                                break;
                            }
                        case 18:
                            {
                                input.ReadMessageArray(tag, field_name, result.contents_, global::Aliyun.Api.LOG.Log.Types.Content.DefaultInstance, extensionRegistry);
                                break;
                            }
                    }
                }

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


            public bool HasTime
            {
                get { return result.hasTime; }
            }
            [global::System.CLSCompliant(false)]
            public uint Time
            {
                get { return result.Time; }
                set { SetTime(value); }
            }
            [global::System.CLSCompliant(false)]
            public Builder SetTime(uint value)
            {
                PrepareBuilder();
                result.hasTime = true;
                result.time_ = value;
                return this;
            }
            public Builder ClearTime()
            {
                PrepareBuilder();
                result.hasTime = false;
                result.time_ = 0;
                return this;
            }

            public pbc::IPopsicleList<global::Aliyun.Api.LOG.Log.Types.Content> ContentsList
            {
                get { return PrepareBuilder().contents_; }
            }
            public int ContentsCount
            {
                get { return result.ContentsCount; }
            }
            public global::Aliyun.Api.LOG.Log.Types.Content GetContents(int index)
            {
                return result.GetContents(index);
            }
            public Builder SetContents(int index, global::Aliyun.Api.LOG.Log.Types.Content value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.contents_[index] = value;
                return this;
            }
            public Builder SetContents(int index, global::Aliyun.Api.LOG.Log.Types.Content.Builder builderForValue)
            {
                pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
                PrepareBuilder();
                result.contents_[index] = builderForValue.Build();
                return this;
            }
            public Builder AddContents(global::Aliyun.Api.LOG.Log.Types.Content value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.contents_.Add(value);
                return this;
            }
            public Builder AddContents(global::Aliyun.Api.LOG.Log.Types.Content.Builder builderForValue)
            {
                pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
                PrepareBuilder();
                result.contents_.Add(builderForValue.Build());
                return this;
            }
            public Builder AddRangeContents(scg::IEnumerable<global::Aliyun.Api.LOG.Log.Types.Content> values)
            {
                PrepareBuilder();
                result.contents_.Add(values);
                return this;
            }
            public Builder ClearContents()
            {
                PrepareBuilder();
                result.contents_.Clear();
                return this;
            }
        }
        static Log()
        {
            object.ReferenceEquals(global::Aliyun.Api.LOG.Proto.LogGroup.Descriptor, null);
        }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class LogGroup : pb::GeneratedMessage<LogGroup, LogGroup.Builder>
    {
        private LogGroup() { }
        private static readonly LogGroup defaultInstance = new LogGroup().MakeReadOnly();
        private static readonly string[] _logGroupFieldNames = new string[] { "Logs", "Reserved", "Source", "Topic" };
        private static readonly uint[] _logGroupFieldTags = new uint[] { 10, 18, 34, 26 };
        public static LogGroup DefaultInstance
        {
            get { return defaultInstance; }
        }

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

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

        public static pbd::MessageDescriptor Descriptor
        {
            get { return global::Aliyun.Api.LOG.Proto.LogGroup.internal__static_LogGroup__Descriptor; }
        }

        protected override pb::FieldAccess.FieldAccessorTable<LogGroup, LogGroup.Builder> InternalFieldAccessors
        {
            get { return global::Aliyun.Api.LOG.Proto.LogGroup.internal__static_LogGroup__FieldAccessorTable; }
        }

        public const int LogsFieldNumber = 1;
        private pbc::PopsicleList<global::Aliyun.Api.LOG.Log> logs_ = new pbc::PopsicleList<global::Aliyun.Api.LOG.Log>();
        public scg::IList<global::Aliyun.Api.LOG.Log> LogsList
        {
            get { return logs_; }
        }
        public int LogsCount
        {
            get { return logs_.Count; }
        }
        public global::Aliyun.Api.LOG.Log GetLogs(int index)
        {
            return logs_[index];
        }

        public const int ReservedFieldNumber = 2;
        private bool hasReserved;
        private string reserved_ = "";
        public bool HasReserved
        {
            get { return hasReserved; }
        }
        public string Reserved
        {
            get { return reserved_; }
        }

        public const int TopicFieldNumber = 3;
        private bool hasTopic;
        private string topic_ = "";
        public bool HasTopic
        {
            get { return hasTopic; }
        }
        public string Topic
        {
            get { return topic_; }
        }

        public const int SourceFieldNumber = 4;
        private bool hasSource;
        private string source_ = "";
        public bool HasSource
        {
            get { return hasSource; }
        }
        public string Source
        {
            get { return source_; }
        }

        public override bool IsInitialized
        {
            get
            {
                foreach (global::Aliyun.Api.LOG.Log element in LogsList)
                {
                    if (!element.IsInitialized) return false;
                }
                return true;
            }
        }

        public override void WriteTo(pb::ICodedOutputStream output)
        {
            int size = SerializedSize;
            string[] field_names = _logGroupFieldNames;
            if (logs_.Count > 0)
            {
                output.WriteMessageArray(1, field_names[0], logs_);
            }
            if (hasReserved)
            {
                output.WriteString(2, field_names[1], Reserved);
            }
            if (hasTopic)
            {
                output.WriteString(3, field_names[3], Topic);
            }
            if (hasSource)
            {
                output.WriteString(4, field_names[2], Source);
            }
            UnknownFields.WriteTo(output);
        }

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

                size = 0;
                foreach (global::Aliyun.Api.LOG.Log element in LogsList)
                {
                    size += pb::CodedOutputStream.ComputeMessageSize(1, element);
                }
                if (hasReserved)
                {
                    size += pb::CodedOutputStream.ComputeStringSize(2, Reserved);
                }
                if (hasTopic)
                {
                    size += pb::CodedOutputStream.ComputeStringSize(3, Topic);
                }
                if (hasSource)
                {
                    size += pb::CodedOutputStream.ComputeStringSize(4, Source);
                }
                size += UnknownFields.SerializedSize;
                memoizedSerializedSize = size;
                return size;
            }
        }

        public static LogGroup ParseFrom(pb::ByteString data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static LogGroup ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static LogGroup ParseFrom(byte[] data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static LogGroup ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static LogGroup ParseFrom(global::System.IO.Stream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static LogGroup ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static LogGroup ParseDelimitedFrom(global::System.IO.Stream input)
        {
            return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static LogGroup ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static LogGroup ParseFrom(pb::ICodedInputStream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static LogGroup ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        private LogGroup MakeReadOnly()
        {
            logs_.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(LogGroup prototype)
        {
            return new Builder(prototype);
        }

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

            private bool resultIsReadOnly;
            private LogGroup result;

            private LogGroup PrepareBuilder()
            {
                if (resultIsReadOnly)
                {
                    LogGroup original = result;
                    result = new LogGroup();
                    resultIsReadOnly = false;
                    MergeFrom(original);
                }
                return result;
            }

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

            protected override LogGroup 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 global::Aliyun.Api.LOG.LogGroup.Descriptor; }
            }

            public override LogGroup DefaultInstanceForType
            {
                get { return global::Aliyun.Api.LOG.LogGroup.DefaultInstance; }
            }

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

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

            public override Builder MergeFrom(LogGroup other)
            {
                if (other == global::Aliyun.Api.LOG.LogGroup.DefaultInstance) return this;
                PrepareBuilder();
                if (other.logs_.Count != 0)
                {
                    result.logs_.Add(other.logs_);
                }
                if (other.HasReserved)
                {
                    Reserved = other.Reserved;
                }
                if (other.HasTopic)
                {
                    Topic = other.Topic;
                }
                if (other.HasSource)
                {
                    Source = other.Source;
                }
                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)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_logGroupFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                            tag = _logGroupFieldTags[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 10:
                            {
                                input.ReadMessageArray(tag, field_name, result.logs_, global::Aliyun.Api.LOG.Log.DefaultInstance, extensionRegistry);
                                break;
                            }
                        case 18:
                            {
                                result.hasReserved = input.ReadString(ref result.reserved_);
                                break;
                            }
                        case 26:
                            {
                                result.hasTopic = input.ReadString(ref result.topic_);
                                break;
                            }
                        case 34:
                            {
                                result.hasSource = input.ReadString(ref result.source_);
                                break;
                            }
                    }
                }

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


            public pbc::IPopsicleList<global::Aliyun.Api.LOG.Log> LogsList
            {
                get { return PrepareBuilder().logs_; }
            }
            public int LogsCount
            {
                get { return result.LogsCount; }
            }
            public global::Aliyun.Api.LOG.Log GetLogs(int index)
            {
                return result.GetLogs(index);
            }
            public Builder SetLogs(int index, global::Aliyun.Api.LOG.Log value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.logs_[index] = value;
                return this;
            }
            public Builder SetLogs(int index, global::Aliyun.Api.LOG.Log.Builder builderForValue)
            {
                pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
                PrepareBuilder();
                result.logs_[index] = builderForValue.Build();
                return this;
            }
            public Builder AddLogs(global::Aliyun.Api.LOG.Log value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.logs_.Add(value);
                return this;
            }
            public Builder AddLogs(global::Aliyun.Api.LOG.Log.Builder builderForValue)
            {
                pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
                PrepareBuilder();
                result.logs_.Add(builderForValue.Build());
                return this;
            }
            public Builder AddRangeLogs(scg::IEnumerable<global::Aliyun.Api.LOG.Log> values)
            {
                PrepareBuilder();
                result.logs_.Add(values);
                return this;
            }
            public Builder ClearLogs()
            {
                PrepareBuilder();
                result.logs_.Clear();
                return this;
            }

            public bool HasReserved
            {
                get { return result.hasReserved; }
            }
            public string Reserved
            {
                get { return result.Reserved; }
                set { SetReserved(value); }
            }
            public Builder SetReserved(string value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.hasReserved = true;
                result.reserved_ = value;
                return this;
            }
            public Builder ClearReserved()
            {
                PrepareBuilder();
                result.hasReserved = false;
                result.reserved_ = "";
                return this;
            }

            public bool HasTopic
            {
                get { return result.hasTopic; }
            }
            public string Topic
            {
                get { return result.Topic; }
                set { SetTopic(value); }
            }
            public Builder SetTopic(string value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.hasTopic = true;
                result.topic_ = value;
                return this;
            }
            public Builder ClearTopic()
            {
                PrepareBuilder();
                result.hasTopic = false;
                result.topic_ = "";
                return this;
            }

            public bool HasSource
            {
                get { return result.hasSource; }
            }
            public string Source
            {
                get { return result.Source; }
                set { SetSource(value); }
            }
            public Builder SetSource(string value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.hasSource = true;
                result.source_ = value;
                return this;
            }
            public Builder ClearSource()
            {
                PrepareBuilder();
                result.hasSource = false;
                result.source_ = "";
                return this;
            }
        }
        static LogGroup()
        {
            object.ReferenceEquals(global::Aliyun.Api.LOG.Proto.LogGroup.Descriptor, null);
        }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class LogGroupList : pb::GeneratedMessage<LogGroupList, LogGroupList.Builder>
    {
        private LogGroupList() { }
        private static readonly LogGroupList defaultInstance = new LogGroupList().MakeReadOnly();
        private static readonly string[] _logGroupListFieldNames = new string[] { "logGroupList" };
        private static readonly uint[] _logGroupListFieldTags = new uint[] { 10 };
        public static LogGroupList DefaultInstance
        {
            get { return defaultInstance; }
        }

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

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

        public static pbd::MessageDescriptor Descriptor
        {
            get { return global::Aliyun.Api.LOG.Proto.LogGroup.internal__static_LogGroupList__Descriptor; }
        }

        protected override pb::FieldAccess.FieldAccessorTable<LogGroupList, LogGroupList.Builder> InternalFieldAccessors
        {
            get { return global::Aliyun.Api.LOG.Proto.LogGroup.internal__static_LogGroupList__FieldAccessorTable; }
        }

        public const int LogGroupList_FieldNumber = 1;
        private pbc::PopsicleList<global::Aliyun.Api.LOG.LogGroup> logGroupList_ = new pbc::PopsicleList<global::Aliyun.Api.LOG.LogGroup>();
        public scg::IList<global::Aliyun.Api.LOG.LogGroup> LogGroupList_List
        {
            get { return logGroupList_; }
        }
        public int LogGroupList_Count
        {
            get { return logGroupList_.Count; }
        }
        public global::Aliyun.Api.LOG.LogGroup GetLogGroupList_(int index)
        {
            return logGroupList_[index];
        }

        public override bool IsInitialized
        {
            get
            {
                foreach (global::Aliyun.Api.LOG.LogGroup element in LogGroupList_List)
                {
                    if (!element.IsInitialized) return false;
                }
                return true;
            }
        }

        public override void WriteTo(pb::ICodedOutputStream output)
        {
            int size = SerializedSize;
            string[] field_names = _logGroupListFieldNames;
            if (logGroupList_.Count > 0)
            {
                output.WriteMessageArray(1, field_names[0], logGroupList_);
            }
            UnknownFields.WriteTo(output);
        }

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

                size = 0;
                foreach (global::Aliyun.Api.LOG.LogGroup element in LogGroupList_List)
                {
                    size += pb::CodedOutputStream.ComputeMessageSize(1, element);
                }
                size += UnknownFields.SerializedSize;
                memoizedSerializedSize = size;
                return size;
            }
        }

        public static LogGroupList ParseFrom(pb::ByteString data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static LogGroupList ParseFrom(pb::ByteString data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static LogGroupList ParseFrom(byte[] data)
        {
            return ((Builder)CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static LogGroupList ParseFrom(byte[] data, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(data, extensionRegistry)).BuildParsed();
        }
        public static LogGroupList ParseFrom(global::System.IO.Stream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static LogGroupList ParseFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        public static LogGroupList ParseDelimitedFrom(global::System.IO.Stream input)
        {
            return CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
        }
        public static LogGroupList ParseDelimitedFrom(global::System.IO.Stream input, pb::ExtensionRegistry extensionRegistry)
        {
            return CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
        }
        public static LogGroupList ParseFrom(pb::ICodedInputStream input)
        {
            return ((Builder)CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static LogGroupList ParseFrom(pb::ICodedInputStream input, pb::ExtensionRegistry extensionRegistry)
        {
            return ((Builder)CreateBuilder().MergeFrom(input, extensionRegistry)).BuildParsed();
        }
        private LogGroupList MakeReadOnly()
        {
            logGroupList_.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(LogGroupList prototype)
        {
            return new Builder(prototype);
        }

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

            private bool resultIsReadOnly;
            private LogGroupList result;

            private LogGroupList PrepareBuilder()
            {
                if (resultIsReadOnly)
                {
                    LogGroupList original = result;
                    result = new LogGroupList();
                    resultIsReadOnly = false;
                    MergeFrom(original);
                }
                return result;
            }

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

            protected override LogGroupList 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 global::Aliyun.Api.LOG.LogGroupList.Descriptor; }
            }

            public override LogGroupList DefaultInstanceForType
            {
                get { return global::Aliyun.Api.LOG.LogGroupList.DefaultInstance; }
            }

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

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

            public override Builder MergeFrom(LogGroupList other)
            {
                if (other == global::Aliyun.Api.LOG.LogGroupList.DefaultInstance) return this;
                PrepareBuilder();
                if (other.logGroupList_.Count != 0)
                {
                    result.logGroupList_.Add(other.logGroupList_);
                }
                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)
                    {
                        int field_ordinal = global::System.Array.BinarySearch(_logGroupListFieldNames, field_name, global::System.StringComparer.Ordinal);
                        if (field_ordinal >= 0)
                            tag = _logGroupListFieldTags[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 10:
                            {
                                input.ReadMessageArray(tag, field_name, result.logGroupList_, global::Aliyun.Api.LOG.LogGroup.DefaultInstance, extensionRegistry);
                                break;
                            }
                    }
                }

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


            public pbc::IPopsicleList<global::Aliyun.Api.LOG.LogGroup> LogGroupList_List
            {
                get { return PrepareBuilder().logGroupList_; }
            }
            public int LogGroupList_Count
            {
                get { return result.LogGroupList_Count; }
            }
            public global::Aliyun.Api.LOG.LogGroup GetLogGroupList_(int index)
            {
                return result.GetLogGroupList_(index);
            }
            public Builder SetLogGroupList_(int index, global::Aliyun.Api.LOG.LogGroup value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.logGroupList_[index] = value;
                return this;
            }
            public Builder SetLogGroupList_(int index, global::Aliyun.Api.LOG.LogGroup.Builder builderForValue)
            {
                pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
                PrepareBuilder();
                result.logGroupList_[index] = builderForValue.Build();
                return this;
            }
            public Builder AddLogGroupList_(global::Aliyun.Api.LOG.LogGroup value)
            {
                pb::ThrowHelper.ThrowIfNull(value, "value");
                PrepareBuilder();
                result.logGroupList_.Add(value);
                return this;
            }
            public Builder AddLogGroupList_(global::Aliyun.Api.LOG.LogGroup.Builder builderForValue)
            {
                pb::ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
                PrepareBuilder();
                result.logGroupList_.Add(builderForValue.Build());
                return this;
            }
            public Builder AddRangeLogGroupList_(scg::IEnumerable<global::Aliyun.Api.LOG.LogGroup> values)
            {
                PrepareBuilder();
                result.logGroupList_.Add(values);
                return this;
            }
            public Builder ClearLogGroupList_()
            {
                PrepareBuilder();
                result.logGroupList_.Clear();
                return this;
            }
        }
        static LogGroupList()
        {
            object.ReferenceEquals(global::Aliyun.Api.LOG.Proto.LogGroup.Descriptor, null);
        }
    }

    #endregion

}

#endregion Designer generated code