UploadSessionStartError.cs

// <auto-generated>
// Auto-generated by StoneAPI, do not modify.
// </auto-generated>

namespace Dropbox.Api.Files
{
    using sys = System;
    using col = System.Collections.Generic;
    using re = System.Text.RegularExpressions;

    using enc = Dropbox.Api.Stone;

    /// <summary>
    /// <para>The upload session start error object</para>
    /// </summary>
    public class UploadSessionStartError
    {
        #pragma warning disable 108

        /// <summary>
        /// <para>The encoder instance.</para>
        /// </summary>
        internal static enc.StructEncoder<UploadSessionStartError> Encoder = new UploadSessionStartErrorEncoder();

        /// <summary>
        /// <para>The decoder instance.</para>
        /// </summary>
        internal static enc.StructDecoder<UploadSessionStartError> Decoder = new UploadSessionStartErrorDecoder();

        /// <summary>
        /// <para>Initializes a new instance of the <see cref="UploadSessionStartError" />
        /// class.</para>
        /// </summary>
        public UploadSessionStartError()
        {
        }

        /// <summary>
        /// <para>Gets a value indicating whether this instance is
        /// ConcurrentSessionDataNotAllowed</para>
        /// </summary>
        public bool IsConcurrentSessionDataNotAllowed
        {
            get
            {
                return this is ConcurrentSessionDataNotAllowed;
            }
        }

        /// <summary>
        /// <para>Gets this instance as a ConcurrentSessionDataNotAllowed, or
        /// <c>null</c>.</para>
        /// </summary>
        public ConcurrentSessionDataNotAllowed AsConcurrentSessionDataNotAllowed
        {
            get
            {
                return this as ConcurrentSessionDataNotAllowed;
            }
        }

        /// <summary>
        /// <para>Gets a value indicating whether this instance is
        /// ConcurrentSessionCloseNotAllowed</para>
        /// </summary>
        public bool IsConcurrentSessionCloseNotAllowed
        {
            get
            {
                return this is ConcurrentSessionCloseNotAllowed;
            }
        }

        /// <summary>
        /// <para>Gets this instance as a ConcurrentSessionCloseNotAllowed, or
        /// <c>null</c>.</para>
        /// </summary>
        public ConcurrentSessionCloseNotAllowed AsConcurrentSessionCloseNotAllowed
        {
            get
            {
                return this as ConcurrentSessionCloseNotAllowed;
            }
        }

        /// <summary>
        /// <para>Gets a value indicating whether this instance is PayloadTooLarge</para>
        /// </summary>
        public bool IsPayloadTooLarge
        {
            get
            {
                return this is PayloadTooLarge;
            }
        }

        /// <summary>
        /// <para>Gets this instance as a PayloadTooLarge, or <c>null</c>.</para>
        /// </summary>
        public PayloadTooLarge AsPayloadTooLarge
        {
            get
            {
                return this as PayloadTooLarge;
            }
        }

        /// <summary>
        /// <para>Gets a value indicating whether this instance is ContentHashMismatch</para>
        /// </summary>
        public bool IsContentHashMismatch
        {
            get
            {
                return this is ContentHashMismatch;
            }
        }

        /// <summary>
        /// <para>Gets this instance as a ContentHashMismatch, or <c>null</c>.</para>
        /// </summary>
        public ContentHashMismatch AsContentHashMismatch
        {
            get
            {
                return this as ContentHashMismatch;
            }
        }

        /// <summary>
        /// <para>Gets a value indicating whether this instance is Other</para>
        /// </summary>
        public bool IsOther
        {
            get
            {
                return this is Other;
            }
        }

        /// <summary>
        /// <para>Gets this instance as a Other, or <c>null</c>.</para>
        /// </summary>
        public Other AsOther
        {
            get
            {
                return this as Other;
            }
        }

        #region Encoder class

        /// <summary>
        /// <para>Encoder for  <see cref="UploadSessionStartError" />.</para>
        /// </summary>
        private class UploadSessionStartErrorEncoder : enc.StructEncoder<UploadSessionStartError>
        {
            /// <summary>
            /// <para>Encode fields of given value.</para>
            /// </summary>
            /// <param name="value">The value.</param>
            /// <param name="writer">The writer.</param>
            public override void EncodeFields(UploadSessionStartError value, enc.IJsonWriter writer)
            {
                if (value is ConcurrentSessionDataNotAllowed)
                {
                    WriteProperty(".tag", "concurrent_session_data_not_allowed", writer, enc.StringEncoder.Instance);
                    ConcurrentSessionDataNotAllowed.Encoder.EncodeFields((ConcurrentSessionDataNotAllowed)value, writer);
                    return;
                }
                if (value is ConcurrentSessionCloseNotAllowed)
                {
                    WriteProperty(".tag", "concurrent_session_close_not_allowed", writer, enc.StringEncoder.Instance);
                    ConcurrentSessionCloseNotAllowed.Encoder.EncodeFields((ConcurrentSessionCloseNotAllowed)value, writer);
                    return;
                }
                if (value is PayloadTooLarge)
                {
                    WriteProperty(".tag", "payload_too_large", writer, enc.StringEncoder.Instance);
                    PayloadTooLarge.Encoder.EncodeFields((PayloadTooLarge)value, writer);
                    return;
                }
                if (value is ContentHashMismatch)
                {
                    WriteProperty(".tag", "content_hash_mismatch", writer, enc.StringEncoder.Instance);
                    ContentHashMismatch.Encoder.EncodeFields((ContentHashMismatch)value, writer);
                    return;
                }
                if (value is Other)
                {
                    WriteProperty(".tag", "other", writer, enc.StringEncoder.Instance);
                    Other.Encoder.EncodeFields((Other)value, writer);
                    return;
                }
                throw new sys.InvalidOperationException();
            }
        }

        #endregion

        #region Decoder class

        /// <summary>
        /// <para>Decoder for  <see cref="UploadSessionStartError" />.</para>
        /// </summary>
        private class UploadSessionStartErrorDecoder : enc.UnionDecoder<UploadSessionStartError>
        {
            /// <summary>
            /// <para>Create a new instance of type <see cref="UploadSessionStartError"
            /// />.</para>
            /// </summary>
            /// <returns>The struct instance.</returns>
            protected override UploadSessionStartError Create()
            {
                return new UploadSessionStartError();
            }

            /// <summary>
            /// <para>Decode based on given tag.</para>
            /// </summary>
            /// <param name="tag">The tag.</param>
            /// <param name="reader">The json reader.</param>
            /// <returns>The decoded object.</returns>
            protected override UploadSessionStartError Decode(string tag, enc.IJsonReader reader)
            {
                switch (tag)
                {
                    case "concurrent_session_data_not_allowed":
                        return ConcurrentSessionDataNotAllowed.Decoder.DecodeFields(reader);
                    case "concurrent_session_close_not_allowed":
                        return ConcurrentSessionCloseNotAllowed.Decoder.DecodeFields(reader);
                    case "payload_too_large":
                        return PayloadTooLarge.Decoder.DecodeFields(reader);
                    case "content_hash_mismatch":
                        return ContentHashMismatch.Decoder.DecodeFields(reader);
                    default:
                        return Other.Decoder.DecodeFields(reader);
                }
            }
        }

        #endregion

        /// <summary>
        /// <para>Uploading data not allowed when starting concurrent upload session.</para>
        /// </summary>
        public sealed class ConcurrentSessionDataNotAllowed : UploadSessionStartError
        {
            #pragma warning disable 108

            /// <summary>
            /// <para>The encoder instance.</para>
            /// </summary>
            internal static enc.StructEncoder<ConcurrentSessionDataNotAllowed> Encoder = new ConcurrentSessionDataNotAllowedEncoder();

            /// <summary>
            /// <para>The decoder instance.</para>
            /// </summary>
            internal static enc.StructDecoder<ConcurrentSessionDataNotAllowed> Decoder = new ConcurrentSessionDataNotAllowedDecoder();

            /// <summary>
            /// <para>Initializes a new instance of the <see
            /// cref="ConcurrentSessionDataNotAllowed" /> class.</para>
            /// </summary>
            private ConcurrentSessionDataNotAllowed()
            {
            }

            /// <summary>
            /// <para>A singleton instance of ConcurrentSessionDataNotAllowed</para>
            /// </summary>
            public static readonly ConcurrentSessionDataNotAllowed Instance = new ConcurrentSessionDataNotAllowed();

            #region Encoder class

            /// <summary>
            /// <para>Encoder for  <see cref="ConcurrentSessionDataNotAllowed" />.</para>
            /// </summary>
            private class ConcurrentSessionDataNotAllowedEncoder : enc.StructEncoder<ConcurrentSessionDataNotAllowed>
            {
                /// <summary>
                /// <para>Encode fields of given value.</para>
                /// </summary>
                /// <param name="value">The value.</param>
                /// <param name="writer">The writer.</param>
                public override void EncodeFields(ConcurrentSessionDataNotAllowed value, enc.IJsonWriter writer)
                {
                }
            }

            #endregion

            #region Decoder class

            /// <summary>
            /// <para>Decoder for  <see cref="ConcurrentSessionDataNotAllowed" />.</para>
            /// </summary>
            private class ConcurrentSessionDataNotAllowedDecoder : enc.StructDecoder<ConcurrentSessionDataNotAllowed>
            {
                /// <summary>
                /// <para>Create a new instance of type <see
                /// cref="ConcurrentSessionDataNotAllowed" />.</para>
                /// </summary>
                /// <returns>The struct instance.</returns>
                protected override ConcurrentSessionDataNotAllowed Create()
                {
                    return ConcurrentSessionDataNotAllowed.Instance;
                }

            }

            #endregion
        }

        /// <summary>
        /// <para>Can not start a closed concurrent upload session.</para>
        /// </summary>
        public sealed class ConcurrentSessionCloseNotAllowed : UploadSessionStartError
        {
            #pragma warning disable 108

            /// <summary>
            /// <para>The encoder instance.</para>
            /// </summary>
            internal static enc.StructEncoder<ConcurrentSessionCloseNotAllowed> Encoder = new ConcurrentSessionCloseNotAllowedEncoder();

            /// <summary>
            /// <para>The decoder instance.</para>
            /// </summary>
            internal static enc.StructDecoder<ConcurrentSessionCloseNotAllowed> Decoder = new ConcurrentSessionCloseNotAllowedDecoder();

            /// <summary>
            /// <para>Initializes a new instance of the <see
            /// cref="ConcurrentSessionCloseNotAllowed" /> class.</para>
            /// </summary>
            private ConcurrentSessionCloseNotAllowed()
            {
            }

            /// <summary>
            /// <para>A singleton instance of ConcurrentSessionCloseNotAllowed</para>
            /// </summary>
            public static readonly ConcurrentSessionCloseNotAllowed Instance = new ConcurrentSessionCloseNotAllowed();

            #region Encoder class

            /// <summary>
            /// <para>Encoder for  <see cref="ConcurrentSessionCloseNotAllowed" />.</para>
            /// </summary>
            private class ConcurrentSessionCloseNotAllowedEncoder : enc.StructEncoder<ConcurrentSessionCloseNotAllowed>
            {
                /// <summary>
                /// <para>Encode fields of given value.</para>
                /// </summary>
                /// <param name="value">The value.</param>
                /// <param name="writer">The writer.</param>
                public override void EncodeFields(ConcurrentSessionCloseNotAllowed value, enc.IJsonWriter writer)
                {
                }
            }

            #endregion

            #region Decoder class

            /// <summary>
            /// <para>Decoder for  <see cref="ConcurrentSessionCloseNotAllowed" />.</para>
            /// </summary>
            private class ConcurrentSessionCloseNotAllowedDecoder : enc.StructDecoder<ConcurrentSessionCloseNotAllowed>
            {
                /// <summary>
                /// <para>Create a new instance of type <see
                /// cref="ConcurrentSessionCloseNotAllowed" />.</para>
                /// </summary>
                /// <returns>The struct instance.</returns>
                protected override ConcurrentSessionCloseNotAllowed Create()
                {
                    return ConcurrentSessionCloseNotAllowed.Instance;
                }

            }

            #endregion
        }

        /// <summary>
        /// <para>The request payload must be at most 150 MB.</para>
        /// </summary>
        public sealed class PayloadTooLarge : UploadSessionStartError
        {
            #pragma warning disable 108

            /// <summary>
            /// <para>The encoder instance.</para>
            /// </summary>
            internal static enc.StructEncoder<PayloadTooLarge> Encoder = new PayloadTooLargeEncoder();

            /// <summary>
            /// <para>The decoder instance.</para>
            /// </summary>
            internal static enc.StructDecoder<PayloadTooLarge> Decoder = new PayloadTooLargeDecoder();

            /// <summary>
            /// <para>Initializes a new instance of the <see cref="PayloadTooLarge" />
            /// class.</para>
            /// </summary>
            private PayloadTooLarge()
            {
            }

            /// <summary>
            /// <para>A singleton instance of PayloadTooLarge</para>
            /// </summary>
            public static readonly PayloadTooLarge Instance = new PayloadTooLarge();

            #region Encoder class

            /// <summary>
            /// <para>Encoder for  <see cref="PayloadTooLarge" />.</para>
            /// </summary>
            private class PayloadTooLargeEncoder : enc.StructEncoder<PayloadTooLarge>
            {
                /// <summary>
                /// <para>Encode fields of given value.</para>
                /// </summary>
                /// <param name="value">The value.</param>
                /// <param name="writer">The writer.</param>
                public override void EncodeFields(PayloadTooLarge value, enc.IJsonWriter writer)
                {
                }
            }

            #endregion

            #region Decoder class

            /// <summary>
            /// <para>Decoder for  <see cref="PayloadTooLarge" />.</para>
            /// </summary>
            private class PayloadTooLargeDecoder : enc.StructDecoder<PayloadTooLarge>
            {
                /// <summary>
                /// <para>Create a new instance of type <see cref="PayloadTooLarge" />.</para>
                /// </summary>
                /// <returns>The struct instance.</returns>
                protected override PayloadTooLarge Create()
                {
                    return PayloadTooLarge.Instance;
                }

            }

            #endregion
        }

        /// <summary>
        /// <para>The content received by the Dropbox server in this call does not match the
        /// provided content hash.</para>
        /// </summary>
        public sealed class ContentHashMismatch : UploadSessionStartError
        {
            #pragma warning disable 108

            /// <summary>
            /// <para>The encoder instance.</para>
            /// </summary>
            internal static enc.StructEncoder<ContentHashMismatch> Encoder = new ContentHashMismatchEncoder();

            /// <summary>
            /// <para>The decoder instance.</para>
            /// </summary>
            internal static enc.StructDecoder<ContentHashMismatch> Decoder = new ContentHashMismatchDecoder();

            /// <summary>
            /// <para>Initializes a new instance of the <see cref="ContentHashMismatch" />
            /// class.</para>
            /// </summary>
            private ContentHashMismatch()
            {
            }

            /// <summary>
            /// <para>A singleton instance of ContentHashMismatch</para>
            /// </summary>
            public static readonly ContentHashMismatch Instance = new ContentHashMismatch();

            #region Encoder class

            /// <summary>
            /// <para>Encoder for  <see cref="ContentHashMismatch" />.</para>
            /// </summary>
            private class ContentHashMismatchEncoder : enc.StructEncoder<ContentHashMismatch>
            {
                /// <summary>
                /// <para>Encode fields of given value.</para>
                /// </summary>
                /// <param name="value">The value.</param>
                /// <param name="writer">The writer.</param>
                public override void EncodeFields(ContentHashMismatch value, enc.IJsonWriter writer)
                {
                }
            }

            #endregion

            #region Decoder class

            /// <summary>
            /// <para>Decoder for  <see cref="ContentHashMismatch" />.</para>
            /// </summary>
            private class ContentHashMismatchDecoder : enc.StructDecoder<ContentHashMismatch>
            {
                /// <summary>
                /// <para>Create a new instance of type <see cref="ContentHashMismatch"
                /// />.</para>
                /// </summary>
                /// <returns>The struct instance.</returns>
                protected override ContentHashMismatch Create()
                {
                    return ContentHashMismatch.Instance;
                }

            }

            #endregion
        }

        /// <summary>
        /// <para>The other object</para>
        /// </summary>
        public sealed class Other : UploadSessionStartError
        {
            #pragma warning disable 108

            /// <summary>
            /// <para>The encoder instance.</para>
            /// </summary>
            internal static enc.StructEncoder<Other> Encoder = new OtherEncoder();

            /// <summary>
            /// <para>The decoder instance.</para>
            /// </summary>
            internal static enc.StructDecoder<Other> Decoder = new OtherDecoder();

            /// <summary>
            /// <para>Initializes a new instance of the <see cref="Other" /> class.</para>
            /// </summary>
            private Other()
            {
            }

            /// <summary>
            /// <para>A singleton instance of Other</para>
            /// </summary>
            public static readonly Other Instance = new Other();

            #region Encoder class

            /// <summary>
            /// <para>Encoder for  <see cref="Other" />.</para>
            /// </summary>
            private class OtherEncoder : enc.StructEncoder<Other>
            {
                /// <summary>
                /// <para>Encode fields of given value.</para>
                /// </summary>
                /// <param name="value">The value.</param>
                /// <param name="writer">The writer.</param>
                public override void EncodeFields(Other value, enc.IJsonWriter writer)
                {
                }
            }

            #endregion

            #region Decoder class

            /// <summary>
            /// <para>Decoder for  <see cref="Other" />.</para>
            /// </summary>
            private class OtherDecoder : enc.StructDecoder<Other>
            {
                /// <summary>
                /// <para>Create a new instance of type <see cref="Other" />.</para>
                /// </summary>
                /// <returns>The struct instance.</returns>
                protected override Other Create()
                {
                    return Other.Instance;
                }

            }

            #endregion
        }
    }
}