NetDataContractSerializer/Compat.Private.Serialization/Resources/Common/SR.Designer.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Compat {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal partial class SR {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal SR() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Resources.SR", typeof(SR).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The element cannot have &apos;abstract&apos; set to &apos;true&apos;..
        /// </summary>
        internal static string AbstractElementNotSupported {
            get {
                return ResourceManager.GetString("AbstractElementNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type cannot have &apos;abstract&apos; set to &apos;true&apos;..
        /// </summary>
        internal static string AbstractTypeNotSupported {
            get {
                return ResourceManager.GetString("AbstractTypeNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List of referenced collection types contains more than one type with same data contract name. Include only one of the following types. Only matching types can be valid references: {0}.
        /// </summary>
        internal static string AmbiguousReferencedCollectionTypes1 {
            get {
                return ResourceManager.GetString("AmbiguousReferencedCollectionTypes1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List of referenced collection types contains more than one type with data contract name &apos;{0}&apos; in namespace &apos;{1}&apos;. Include only one of the following types. Only matching types can be valid references: {2}.
        /// </summary>
        internal static string AmbiguousReferencedCollectionTypes3 {
            get {
                return ResourceManager.GetString("AmbiguousReferencedCollectionTypes3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List of referenced types contains more than one type with same data contract name. Need to exclude all but one of the following types. Only matching types can be valid references: {0}.
        /// </summary>
        internal static string AmbiguousReferencedTypes1 {
            get {
                return ResourceManager.GetString("AmbiguousReferencedTypes1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List of referenced types contains more than one type with data contract name &apos;{0}&apos; in namespace &apos;{1}&apos;. Need to exclude all but one of the following types. Only matching types can be valid references: {2}.
        /// </summary>
        internal static string AmbiguousReferencedTypes3 {
            get {
                return ResourceManager.GetString("AmbiguousReferencedTypes3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid &apos;{0}&apos; annotation in type &apos;{1}&apos; from namespace &apos;{2}&apos;. Attribute &apos;{3}&apos; not present..
        /// </summary>
        internal static string AnnotationAttributeNotFound {
            get {
                return ResourceManager.GetString("AnnotationAttributeNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Anonymous type in element &apos;{0}&apos; from namespace &apos;{1}&apos; is not supported..
        /// </summary>
        internal static string AnonymousTypeNotSupported {
            get {
                return ResourceManager.GetString("AnonymousTypeNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;anyAttribute&apos; is not supported..
        /// </summary>
        internal static string AnyAttributeNotSupported {
            get {
                return ResourceManager.GetString("AnyAttributeNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Array length &apos;{0}&apos; provided by the get-only collection of type &apos;{1}&apos; is less than the number of array elements found in the input stream.  Consider increasing the length of the array..
        /// </summary>
        internal static string ArrayExceededSize {
            get {
                return ResourceManager.GetString("ArrayExceededSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Array length &apos;{0}&apos; provided by Size attribute is not equal to the number of array elements &apos;{1}&apos; from namespace &apos;{2}&apos; found..
        /// </summary>
        internal static string ArrayExceededSizeAttribute {
            get {
                return ResourceManager.GetString("ArrayExceededSizeAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Form for element &apos;{0}&apos; must be qualified..
        /// </summary>
        internal static string ArrayItemFormMustBe {
            get {
                return ResourceManager.GetString("ArrayItemFormMustBe", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Array Size &apos;{0}&apos; is not equal to the number of elements found &apos;{1}&apos;..
        /// </summary>
        internal static string ArraySizeAttributeIncorrect {
            get {
                return ResourceManager.GetString("ArraySizeAttributeIncorrect", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Array type &apos;{0}&apos; in namespace &apos;{1}&apos; cannot be imported. {2}.
        /// </summary>
        internal static string ArrayTypeCannotBeImported {
            get {
                return ResourceManager.GetString("ArrayTypeCannotBeImported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ArrayTypeIsNotSupported: {0}.
        /// </summary>
        internal static string ArrayTypeIsNotSupported {
            get {
                return ResourceManager.GetString("ArrayTypeIsNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An internal error has occurred. &apos;{0}[]&apos; is not supported when generating code for serialization..
        /// </summary>
        internal static string ArrayTypeIsNotSupported_GeneratingCode {
            get {
                return ResourceManager.GetString("ArrayTypeIsNotSupported_GeneratingCode", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assembly &apos;{0}&apos; is not found..
        /// </summary>
        internal static string AssemblyNotFound {
            get {
                return ResourceManager.GetString("AssemblyNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot inherit from a type that is not marked with DataContractAttribute or SerializableAttribute.  Consider marking the base type &apos;{1}&apos; with DataContractAttribute or SerializableAttribute, or removing them from the derived type..
        /// </summary>
        internal static string AttributedTypesCannotInheritFromNonAttributedSerializableTypes {
            get {
                return ResourceManager.GetString("AttributedTypesCannotInheritFromNonAttributedSerializableTypes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XML &apos;{2}&apos; &apos;{3}:{4}&apos; does not contain expected attribute &apos;{0}:{1}&apos;. The deserializer has no knowledge of which type to deserialize. Check that the type being serialized has the same contract as the type being deserialized..
        /// </summary>
        internal static string AttributeNotFound {
            get {
                return ResourceManager.GetString("AttributeNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to One of its base types, &apos;{0}&apos; from namespace &apos;{1}&apos; is not ISerializable..
        /// </summary>
        internal static string BaseTypeNotISerializable {
            get {
                return ResourceManager.GetString("BaseTypeNotISerializable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Serialization Callback &apos;{1}&apos; in type &apos;{0}&apos; must return void. .
        /// </summary>
        internal static string CallbackMustReturnVoid {
            get {
                return ResourceManager.GetString("CallbackMustReturnVoid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Serialization Callback &apos;{1}&apos; in type &apos;{0}&apos; must have a single parameter of type &apos;{2}&apos;. .
        /// </summary>
        internal static string CallbackParameterInvalid {
            get {
                return ResourceManager.GetString("CallbackParameterInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Virtual Method &apos;{0}&apos; of type &apos;{1}&apos; cannot be marked with &apos;{2}&apos; attribute. .
        /// </summary>
        internal static string CallbacksCannotBeVirtualMethods {
            get {
                return ResourceManager.GetString("CallbacksCannotBeVirtualMethods", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A unique name cannot be computed for &apos;{0}&apos; because there are already Int32.MaxValue types of with the same name..
        /// </summary>
        internal static string CannotComputeUniqueName {
            get {
                return ResourceManager.GetString("CannotComputeUniqueName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot deserialize since root element references unrecognized object with id &apos;{0}&apos;..
        /// </summary>
        internal static string CannotDeserializeRefAtTopLevel {
            get {
                return ResourceManager.GetString("CannotDeserializeRefAtTopLevel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot export null assembly provided via &apos;{0}&apos; parameter..
        /// </summary>
        internal static string CannotExportNullAssembly {
            get {
                return ResourceManager.GetString("CannotExportNullAssembly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot export null type provided via KnownTypesCollection..
        /// </summary>
        internal static string CannotExportNullKnownType {
            get {
                return ResourceManager.GetString("CannotExportNullKnownType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot export null type provided via &apos;{0}&apos; parameter..
        /// </summary>
        internal static string CannotExportNullType {
            get {
                return ResourceManager.GetString("CannotExportNullType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type contains two attributes with the same name &apos;{0}&apos;. Multiple attributes with the same name in one type are not supported..
        /// </summary>
        internal static string CannotHaveDuplicateAttributeNames {
            get {
                return ResourceManager.GetString("CannotHaveDuplicateAttributeNames", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type contains two elements with the same name &apos;{0}&apos;. Multiple elements with the same name in one type are not supported because members marked with DataMemberAttribute attribute must have unique names..
        /// </summary>
        internal static string CannotHaveDuplicateElementNames {
            get {
                return ResourceManager.GetString("CannotHaveDuplicateElementNames", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot import invalid schemas. Compilation on the XmlSchemaSet failed..
        /// </summary>
        internal static string CannotImportInvalidSchemas {
            get {
                return ResourceManager.GetString("CannotImportInvalidSchemas", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot import type for null XmlQualifiedName specified via parameter..
        /// </summary>
        internal static string CannotImportNullDataContractName {
            get {
                return ResourceManager.GetString("CannotImportNullDataContractName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot import null XmlSchema contained in XmlSchemaSet specified via parameter..
        /// </summary>
        internal static string CannotImportNullSchema {
            get {
                return ResourceManager.GetString("CannotImportNullSchema", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot load member type &apos;{0}&apos;..
        /// </summary>
        internal static string CannotLoadMemberType {
            get {
                return ResourceManager.GetString("CannotLoadMemberType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Object graph for type &apos;{0}&apos; contains cycles and cannot be serialized if references are not tracked. Consider using the DataContractAttribute with the IsReference property set to true..
        /// </summary>
        internal static string CannotSerializeObjectWithCycles {
            get {
                return ResourceManager.GetString("CannotSerializeObjectWithCycles", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An internal error has occurred. Data can only be stored into ArgBuilder or LocalBuilder. Got: {0}..
        /// </summary>
        internal static string CanOnlyStoreIntoArgOrLocGot0 {
            get {
                return ResourceManager.GetString("CanOnlyStoreIntoArgOrLocGot0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataContractJsonSerializer does not support the setting of the FullTypeName of the object to be serialized to a value other than the default FullTypeName. Attempted to serialize object with full type name &apos;{0}&apos; and default full type name &apos;{1}&apos;..
        /// </summary>
        internal static string ChangingFullTypeNameNotSupported {
            get {
                return ResourceManager.GetString("ChangingFullTypeNameNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An internal error has occurred. Char is not a valid schema primitive and should be treated as int in DataContract..
        /// </summary>
        internal static string CharIsInvalidPrimitive {
            get {
                return ResourceManager.GetString("CharIsInvalidPrimitive", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ClassDataContractReturnedForGetOnlyCollection: {0}.
        /// </summary>
        internal static string ClassDataContractReturnedForGetOnlyCollection {
            get {
                return ResourceManager.GetString("ClassDataContractReturnedForGetOnlyCollection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The deserializer cannot load the type to deserialize because type &apos;{1}&apos; could not be found in assembly &apos;{0}&apos;. Check that the type being serialized has the same contract as the type being deserialized and the same assembly is used..
        /// </summary>
        internal static string ClrTypeNotFound {
            get {
                return ResourceManager.GetString("ClrTypeNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is a collection type and cannot be serialized when assigned to an interface type that does not implement IEnumerable (&apos;{1}&apos;.).
        /// </summary>
        internal static string CollectionAssignedToIncompatibleInterface {
            get {
                return ResourceManager.GetString("CollectionAssignedToIncompatibleInterface", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Collection type &apos;{0}&apos; does not have a valid Add method..
        /// </summary>
        internal static string CollectionMustHaveAddMethod {
            get {
                return ResourceManager.GetString("CollectionMustHaveAddMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Collection type &apos;{0}&apos; does not have a valid GetEnumerator method..
        /// </summary>
        internal static string CollectionMustHaveGetEnumeratorMethod {
            get {
                return ResourceManager.GetString("CollectionMustHaveGetEnumeratorMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Collection type &apos;{0}&apos; must have a non-null item type..
        /// </summary>
        internal static string CollectionMustHaveItemType {
            get {
                return ResourceManager.GetString("CollectionMustHaveItemType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} is a built-in type and cannot be a collection..
        /// </summary>
        internal static string CollectionTypeCannotBeBuiltIn {
            get {
                return ResourceManager.GetString("CollectionTypeCannotBeBuiltIn", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} has DataContractAttribute attribute..
        /// </summary>
        internal static string CollectionTypeCannotHaveDataContract {
            get {
                return ResourceManager.GetString("CollectionTypeCannotHaveDataContract", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} does not have a valid Add method with parameter of type &apos;{1}&apos;..
        /// </summary>
        internal static string CollectionTypeDoesNotHaveAddMethod {
            get {
                return ResourceManager.GetString("CollectionTypeDoesNotHaveAddMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} does not have a default constructor..
        /// </summary>
        internal static string CollectionTypeDoesNotHaveDefaultCtor {
            get {
                return ResourceManager.GetString("CollectionTypeDoesNotHaveDefaultCtor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} has multiple definitions of interface &apos;{1}&apos;..
        /// </summary>
        internal static string CollectionTypeHasMultipleDefinitionsOfInterface {
            get {
                return ResourceManager.GetString("CollectionTypeHasMultipleDefinitionsOfInterface", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} does not implement IEnumerable interface..
        /// </summary>
        internal static string CollectionTypeIsNotIEnumerable {
            get {
                return ResourceManager.GetString("CollectionTypeIsNotIEnumerable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The combined length of the prefix and namespace must not be greater than {0}..
        /// </summary>
        internal static string CombinedPrefixNSLength {
            get {
                return ResourceManager.GetString("CombinedPrefixNSLength", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Complex types derived by restriction not supported. .
        /// </summary>
        internal static string ComplexTypeRestrictionNotSupported {
            get {
                return ResourceManager.GetString("ComplexTypeRestrictionNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An internal error has occurred. Could not load serialization schema. Consider providing schema with namespace &apos;{0}&apos;..
        /// </summary>
        internal static string CouldNotReadSerializationSchema {
            get {
                return ResourceManager.GetString("CouldNotReadSerializationSchema", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An internal error has occurred. DataContract cache overflow..
        /// </summary>
        internal static string DataContractCacheOverflow {
            get {
                return ResourceManager.GetString("DataContractCacheOverflow", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ContractNamespaceAttribute attribute maps CLR namespace &apos;{2}&apos; to multiple data contract namespaces &apos;{0}&apos; and &apos;{1}&apos;. You can map a CLR namespace to only one data contract namespace..
        /// </summary>
        internal static string DataContractNamespaceAlreadySet {
            get {
                return ResourceManager.GetString("DataContractNamespaceAlreadySet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataContract namespace &apos;{0}&apos; is not a valid URI..
        /// </summary>
        internal static string DataContractNamespaceIsNotValid {
            get {
                return ResourceManager.GetString("DataContractNamespaceIsNotValid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataContract namespace &apos;{0}&apos; cannot be specified since it is reserved..
        /// </summary>
        internal static string DataContractNamespaceReserved {
            get {
                return ResourceManager.GetString("DataContractNamespaceReserved", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}.{1}&apos; has DataMemberAttribute attribute. Use EnumMemberAttribute attribute instead..
        /// </summary>
        internal static string DataMemberOnEnumField {
            get {
                return ResourceManager.GetString("DataMemberOnEnumField", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Element &apos;{2}:{3}&apos; contains data of the &apos;{0}:{1}&apos; data contract. The deserializer has no knowledge of any type that maps to this contract. Add the type corresponding to &apos;{1}&apos; to the list of known types - for example, by using the KnownTypeAttribute attribute or by adding it to the list of known types passed to DataContractSerializer..
        /// </summary>
        internal static string DcTypeNotFoundOnDeserialize {
            get {
                return ResourceManager.GetString("DcTypeNotFoundOnDeserialize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; with data contract name &apos;{1}:{2}&apos; is not expected. Add any types not known statically to the list of known types - for example, by using the KnownTypeAttribute attribute or by adding them to the list of known types passed to DataContractSerializer..
        /// </summary>
        internal static string DcTypeNotFoundOnSerialize {
            get {
                return ResourceManager.GetString("DcTypeNotFoundOnSerialize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Element &apos;{2}:{3}&apos; contains data from a type that maps to the name &apos;{0}:{1}&apos;. The deserializer has no knowledge of any type that maps to this name. Consider changing the implementation of the ResolveName method on your DataContractResolver to return a non-null value for name &apos;{1}&apos; and namespace &apos;{0}&apos;..
        /// </summary>
        internal static string DcTypeNotResolvedOnDeserialize {
            get {
                return ResourceManager.GetString("DcTypeNotResolvedOnDeserialize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Default value on element &apos;{0}&apos; is not supported..
        /// </summary>
        internal static string DefaultOnElementNotSupported {
            get {
                return ResourceManager.GetString("DefaultOnElementNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to It is not ISerializable but its base type &apos;{0}&apos; in namespace &apos;{1}&apos; is ISerializable..
        /// </summary>
        internal static string DerivedTypeNotISerializable {
            get {
                return ResourceManager.GetString("DerivedTypeNotISerializable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deserialized object with reference id &apos;{0}&apos; not found in stream..
        /// </summary>
        internal static string DeserializedObjectWithIdNotFound {
            get {
                return ResourceManager.GetString("DeserializedObjectWithIdNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataContract with name &apos;{0}&apos; and namespace &apos;{1}&apos; cannot be added to DataContractSet since another contract with the same data contract name is already present and the contracts are not equivalent..
        /// </summary>
        internal static string DupContractInDataContractSet {
            get {
                return ResourceManager.GetString("DupContractInDataContractSet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot be added to list of known types since another type &apos;{1}&apos; with the same data contract name &apos;{2}:{3}&apos; is already present..
        /// </summary>
        internal static string DupContractInKnownTypes {
            get {
                return ResourceManager.GetString("DupContractInKnownTypes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{2}&apos; contains two members &apos;{0}&apos; &apos;and &apos;{1}&apos; with the same name &apos;{3}&apos;. Multiple members with the same name in one type are not supported. Consider changing one of the member names using EnumMemberAttribute attribute..
        /// </summary>
        internal static string DupEnumMemberValue {
            get {
                return ResourceManager.GetString("DupEnumMemberValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection data contract type &apos;{0}&apos; specifies the same value &apos;{1}&apos; for both the KeyName and the ValueName properties. This is not allowed. Consider changing either the KeyName or the ValueName property..
        /// </summary>
        internal static string DupKeyValueName {
            get {
                return ResourceManager.GetString("DupKeyValueName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid Callback. Method &apos;{3}&apos; in type &apos;{2}&apos; has both &apos;{0}&apos; and &apos;{1}&apos;. .
        /// </summary>
        internal static string DuplicateAttribute {
            get {
                return ResourceManager.GetString("DuplicateAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid attribute. Both &apos;{0}&apos; and &apos;{1}&apos; in type &apos;{2}&apos; have &apos;{3}&apos;. .
        /// </summary>
        internal static string DuplicateCallback {
            get {
                return ResourceManager.GetString("DuplicateCallback", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid IExtensibleDataObject. Both &apos;{0}&apos; and &apos;{1}&apos; in type &apos;{2}&apos; provide property setter..
        /// </summary>
        internal static string DuplicateExtensionDataSetMethod {
            get {
                return ResourceManager.GetString("DuplicateExtensionDataSetMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{2}&apos; contains two members &apos;{0}&apos; &apos;and &apos;{1}&apos; with the same data member name &apos;{3}&apos;. Multiple members with the same name in one type are not supported. Consider changing one of the member names using DataMemberAttribute attribute..
        /// </summary>
        internal static string DupMemberName {
            get {
                return ResourceManager.GetString("DupMemberName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataContract for type &apos;{0}&apos; cannot be added to DataContractSet since type &apos;{1}&apos; with the same data contract name &apos;{2}&apos; in namespace &apos;{3}&apos; is already present and the contracts are not equivalent..
        /// </summary>
        internal static string DupTypeContractInDataContractSet {
            get {
                return ResourceManager.GetString("DupTypeContractInDataContractSet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;maxOccurs&apos; on element &apos;{0}&apos; must be 1..
        /// </summary>
        internal static string ElementMaxOccursMustBe {
            get {
                return ResourceManager.GetString("ElementMaxOccursMustBe", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;minOccurs&apos; on element &apos;{0}&apos; must be 0 or 1..
        /// </summary>
        internal static string ElementMinOccursMustBe {
            get {
                return ResourceManager.GetString("ElementMinOccursMustBe", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ref to element &apos;{0}&apos; in &apos;{1}&apos; namespace is not supported..
        /// </summary>
        internal static string ElementRefOnLocalElementNotSupported {
            get {
                return ResourceManager.GetString("ElementRefOnLocalElementNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}. Encountered &apos;{1}&apos;  with name &apos;{2}&apos;, namespace &apos;{3}&apos;..
        /// </summary>
        internal static string EncounteredWithNameNamespace {
            get {
                return ResourceManager.GetString("EncounteredWithNameNamespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enumeration facets without &apos;value&apos; are not supported..
        /// </summary>
        internal static string EnumEnumerationFacetsMustHaveValue {
            get {
                return ResourceManager.GetString("EnumEnumerationFacetsMustHaveValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Anonymous type with &lt;list&gt; cannot be used to create Flags enumeration because it is not a valid enum type..
        /// </summary>
        internal static string EnumListInAnonymousTypeNotSupported {
            get {
                return ResourceManager.GetString("EnumListInAnonymousTypeNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Simple type list must contain an anonymous type specifying enumeration facets..
        /// </summary>
        internal static string EnumListMustContainAnonymousType {
            get {
                return ResourceManager.GetString("EnumListMustContainAnonymousType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Facets other than enumeration facets are not supported..
        /// </summary>
        internal static string EnumOnlyEnumerationFacetsSupported {
            get {
                return ResourceManager.GetString("EnumOnlyEnumerationFacetsSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Anonymous type with &lt;restriction&gt; cannot be used to create Flags enumeration because it is not a valid enum type..
        /// </summary>
        internal static string EnumRestrictionInvalid {
            get {
                return ResourceManager.GetString("EnumRestrictionInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enum type &apos;{0}&apos; in namespace &apos;{1}&apos; cannot be imported. {2}.
        /// </summary>
        internal static string EnumTypeCannotBeImported {
            get {
                return ResourceManager.GetString("EnumTypeCannotBeImported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enum type &apos;{0}&apos; cannot have the IsReference setting of &apos;{1}&apos;. Either change the setting to &apos;{2}&apos;, or remove it completely..
        /// </summary>
        internal static string EnumTypeCannotHaveIsReference {
            get {
                return ResourceManager.GetString("EnumTypeCannotHaveIsReference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataContractJsonSerializer does not support data members of type &apos;{0}&apos;.  Consider using int, System.Object, or a concrete enum definition instead..
        /// </summary>
        internal static string EnumTypeNotSupportedByDataContractJsonSerializer {
            get {
                return ResourceManager.GetString("EnumTypeNotSupportedByDataContractJsonSerializer", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Anonymous type with &lt;union&gt;. cannot be used to create Flags enumeration because it is not a valid enum type..
        /// </summary>
        internal static string EnumUnionInAnonymousTypeNotSupported {
            get {
                return ResourceManager.GetString("EnumUnionInAnonymousTypeNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There was an error deserializing the object {0}. {1}.
        /// </summary>
        internal static string ErrorDeserializing {
            get {
                return ResourceManager.GetString("ErrorDeserializing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error in line {0} position {1}..
        /// </summary>
        internal static string ErrorInLine {
            get {
                return ResourceManager.GetString("ErrorInLine", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There was an error checking start element of object {0}. {1}.
        /// </summary>
        internal static string ErrorIsStartObject {
            get {
                return ResourceManager.GetString("ErrorIsStartObject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There was an error serializing the object {0}. {1}.
        /// </summary>
        internal static string ErrorSerializing {
            get {
                return ResourceManager.GetString("ErrorSerializing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to of type {0}.
        /// </summary>
        internal static string ErrorTypeInfo {
            get {
                return ResourceManager.GetString("ErrorTypeInfo", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There was an error writing end element of object {0}. {1}.
        /// </summary>
        internal static string ErrorWriteEndObject {
            get {
                return ResourceManager.GetString("ErrorWriteEndObject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There was an error writing start element of object {0}. {1}.
        /// </summary>
        internal static string ErrorWriteStartObject {
            get {
                return ResourceManager.GetString("ErrorWriteStartObject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Maximum number of items that can be serialized or deserialized in an object graph is &apos;{0}&apos;..
        /// </summary>
        internal static string ExceededMaxItemsQuota {
            get {
                return ResourceManager.GetString("ExceededMaxItemsQuota", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expecting element &apos;{1}&apos; from namespace &apos;{0}&apos;..
        /// </summary>
        internal static string ExpectingElement {
            get {
                return ResourceManager.GetString("ExpectingElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expecting state &apos;{0}&apos; when ReadObject is called..
        /// </summary>
        internal static string ExpectingElementAtDeserialize {
            get {
                return ResourceManager.GetString("ExpectingElementAtDeserialize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expecting End&apos;{0}&apos;..
        /// </summary>
        internal static string ExpectingEnd {
            get {
                return ResourceManager.GetString("ExpectingEnd", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expecting state &apos;{0}&apos;..
        /// </summary>
        internal static string ExpectingState {
            get {
                return ResourceManager.GetString("ExpectingState", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to IExtensibleDataObject property setter &apos;{1}&apos; in type &apos;{0}&apos; must return void..
        /// </summary>
        internal static string ExtensionDataSetMustReturnVoid {
            get {
                return ResourceManager.GetString("ExtensionDataSetMustReturnVoid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to IExtensibleDataObject property setter &apos;{1}&apos; in type &apos;{0}&apos; must have a single parameter of type &apos;{2}&apos;..
        /// </summary>
        internal static string ExtensionDataSetParameterInvalid {
            get {
                return ResourceManager.GetString("ExtensionDataSetParameterInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Object graph of type &apos;{0}&apos; with Id &apos;{2}&apos; contains a reference to itself. The object has been replaced with a new object of type &apos;{1}&apos; either because it implements IObjectReference or because it is surrogated. The serializer does not support fixing up the nested reference to the new object and cannot deserialize this object. Consider changing the object to remove the nested self-reference..
        /// </summary>
        internal static string FactoryObjectContainsSelfReference {
            get {
                return ResourceManager.GetString("FactoryObjectContainsSelfReference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Factory type &apos;{0}&apos; for ISerializable type &apos;{1}&apos; must also be ISerializable..
        /// </summary>
        internal static string FactoryTypeNotISerializable {
            get {
                return ResourceManager.GetString("FactoryTypeNotISerializable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Failed to create Delegate for method &apos;{0}&apos; of type &apos;{1}&apos;..
        /// </summary>
        internal static string FailedToCreateMethodDelegate {
            get {
                return ResourceManager.GetString("FailedToCreateMethodDelegate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fixed value on element &apos;{0}&apos; is not supported..
        /// </summary>
        internal static string FixedOnElementNotSupported {
            get {
                return ResourceManager.GetString("FixedOnElementNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Form on element &apos;{0}&apos; must be qualified..
        /// </summary>
        internal static string FormMustBeQualified {
            get {
                return ResourceManager.GetString("FormMustBeQualified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation for generic type &apos;{0}&apos; did not have attribute &apos;{1}&apos;..
        /// </summary>
        internal static string GenericAnnotationAttributeNotFound {
            get {
                return ResourceManager.GetString("GenericAnnotationAttributeNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Nested level on annotation elements &apos;{0}&apos; from namespace &apos;{1}&apos; for generic type &apos;{2}&apos; must be in increasing order..
        /// </summary>
        internal static string GenericAnnotationForNestedLevelMustBeIncreasing {
            get {
                return ResourceManager.GetString("GenericAnnotationForNestedLevelMustBeIncreasing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation element &apos;{0}&apos; from namespace &apos;{1}&apos; for generic type &apos;{2}&apos; has an invalid value &apos;{3}&apos; for attribute &apos;{4}&apos;. Expecting value to be of type &apos;{5}&apos;..
        /// </summary>
        internal static string GenericAnnotationHasInvalidAttributeValue {
            get {
                return ResourceManager.GetString("GenericAnnotationHasInvalidAttributeValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation for generic type &apos;{2}&apos; has an invalid element &apos;{0}&apos; from namespace &apos;{1}&apos;..
        /// </summary>
        internal static string GenericAnnotationHasInvalidElement {
            get {
                return ResourceManager.GetString("GenericAnnotationHasInvalidElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A user callback threw an exception.  Check the exception stack and inner exception to determine the callback that failed..
        /// </summary>
        internal static string GenericCallbackException {
            get {
                return ResourceManager.GetString("GenericCallbackException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract name &apos;{0}&apos; for type &apos;{1}&apos; has a curly brace &apos;{{&apos; that is not matched with a closing curly brace. Curly braces have special meaning in data contract names - they are used to customize the naming of data contracts for generic types..
        /// </summary>
        internal static string GenericNameBraceMismatch {
            get {
                return ResourceManager.GetString("GenericNameBraceMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In the data contract name for type &apos;{1}&apos;, there are curly braces with &apos;{0}&apos; inside, which is an invalid value. Curly braces have special meaning in data contract names - they are used to customize the naming of data contracts for generic types. Based on the number of generic parameters this type has, the contents of the curly braces must either be a number between 0 and &apos;{2}&apos; to insert the name of the generic parameter at that index or the &apos;#&apos; symbol to insert a digest of the generic parameter namespaces..
        /// </summary>
        internal static string GenericParameterNotValid {
            get {
                return ResourceManager.GetString("GenericParameterNotValid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot be exported as a schema type because it is an open generic type. You can only export a generic type if all its generic parameter types are actual types..
        /// </summary>
        internal static string GenericTypeNotExportable {
            get {
                return ResourceManager.GetString("GenericTypeNotExportable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Collection interface type &apos;{0}&apos; is being used as a get-only property and does not have an Add method. Consider adding a setter to the property or using a collection data contract that does have an Add method - for example IList or ICollection&lt;T&gt;..
        /// </summary>
        internal static string GetOnlyCollectionMustHaveAddMethod {
            get {
                return ResourceManager.GetString("GetOnlyCollectionMustHaveAddMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to GetRealObjectReturnedNull: {0}.
        /// </summary>
        internal static string GetRealObjectReturnedNull {
            get {
                return ResourceManager.GetString("GetRealObjectReturnedNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The IsReference setting for type &apos;{0}&apos; is &apos;{1}&apos;, but the same setting for its parent class &apos;{2}&apos; is &apos;{3}&apos;. Derived types must have the same value for IsReference as the base type. Change the setting on type &apos;{0}&apos; to &apos;{3}&apos;, or on type &apos;{2}&apos; to &apos;{1}&apos;, or do not set IsReference explicitly..
        /// </summary>
        internal static string InconsistentIsReference {
            get {
                return ResourceManager.GetString("InconsistentIsReference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property &apos;{1}&apos; in type &apos;{0}&apos; cannot be serialized because serialization of indexed properties is not supported..
        /// </summary>
        internal static string IndexedPropertyCannotBeSerialized {
            get {
                return ResourceManager.GetString("IndexedPropertyCannotBeSerialized", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Interface type &apos;{0}&apos; cannot be created. Consider replacing with a non-interface serializable type..
        /// </summary>
        internal static string InterfaceTypeCannotBeCreated {
            get {
                return ResourceManager.GetString("InterfaceTypeCannotBeCreated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation &apos;{0}&apos; from namespace &apos;{1}&apos; has an invalid element &apos;{2}&apos; from namespace &apos;{3}&apos;. Expecting text..
        /// </summary>
        internal static string InvalidAnnotationExpectingText {
            get {
                return ResourceManager.GetString("InvalidAnnotationExpectingText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid assembly format: {0}.
        /// </summary>
        internal static string InvalidAssemblyFormat {
            get {
                return ResourceManager.GetString("InvalidAssemblyFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encountered invalid character &apos;{0}&apos;..
        /// </summary>
        internal static string InvalidCharacterEncountered {
            get {
                return ResourceManager.GetString("InvalidCharacterEncountered", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; in namespace &apos;{1}&apos; cannot be used as the base type of a data contract type, because it itself does not have a data contract. Consider marking type &apos;{0}&apos; with the DataContractAttribute attribute..
        /// </summary>
        internal static string InvalidClassDerivation {
            get {
                return ResourceManager.GetString("InvalidClassDerivation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot have CollectionDataContractAttribute attribute ItemName set to null or empty string..
        /// </summary>
        internal static string InvalidCollectionContractItemName {
            get {
                return ResourceManager.GetString("InvalidCollectionContractItemName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot have CollectionDataContractAttribute attribute KeyName set to null or empty string..
        /// </summary>
        internal static string InvalidCollectionContractKeyName {
            get {
                return ResourceManager.GetString("InvalidCollectionContractKeyName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection data contract type &apos;{0}&apos; specifies &apos;{1}&apos; for the KeyName property. This is not allowed since the type is not IDictionary. Remove the setting for the KeyName property..
        /// </summary>
        internal static string InvalidCollectionContractKeyNoDictionary {
            get {
                return ResourceManager.GetString("InvalidCollectionContractKeyNoDictionary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot have CollectionDataContractAttribute attribute Name set to null or empty string..
        /// </summary>
        internal static string InvalidCollectionContractName {
            get {
                return ResourceManager.GetString("InvalidCollectionContractName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot have CollectionDataContractAttribute attribute Namespace set to null..
        /// </summary>
        internal static string InvalidCollectionContractNamespace {
            get {
                return ResourceManager.GetString("InvalidCollectionContractNamespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot have CollectionDataContractAttribute attribute ValueName set to null or empty string..
        /// </summary>
        internal static string InvalidCollectionContractValueName {
            get {
                return ResourceManager.GetString("InvalidCollectionContractValueName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection data contract type &apos;{0}&apos; specifies &apos;{1}&apos; for the ValueName property. This is not allowed since the type is not IDictionary. Remove the setting for the ValueName property..
        /// </summary>
        internal static string InvalidCollectionContractValueNoDictionary {
            get {
                return ResourceManager.GetString("InvalidCollectionContractValueNoDictionary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; with CollectionDataContractAttribute attribute is an invalid collection type since it.
        /// </summary>
        internal static string InvalidCollectionDataContract {
            get {
                return ResourceManager.GetString("InvalidCollectionDataContract", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; is an invalid collection type since it.
        /// </summary>
        internal static string InvalidCollectionType {
            get {
                return ResourceManager.GetString("InvalidCollectionType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot have DataContractAttribute attribute Name set to null or empty string..
        /// </summary>
        internal static string InvalidDataContractName {
            get {
                return ResourceManager.GetString("InvalidDataContractName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot have DataContractAttribute attribute Namespace set to null..
        /// </summary>
        internal static string InvalidDataContractNamespace {
            get {
                return ResourceManager.GetString("InvalidDataContractNamespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}&apos; in type &apos;{1}&apos; cannot have DataMemberAttribute attribute Name set to null or empty string..
        /// </summary>
        internal static string InvalidDataMemberName {
            get {
                return ResourceManager.GetString("InvalidDataMemberName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to InvalidDataNode: {0}.
        /// </summary>
        internal static string InvalidDataNode {
            get {
                return ResourceManager.GetString("InvalidDataNode", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation for element {0} in type {1} from namespace {2} specifies EmitDefaultValue as &apos;true&apos;. This requires the element to be either nillable or the element&apos;s type must be a value type..
        /// </summary>
        internal static string InvalidEmitDefaultAnnotation {
            get {
                return ResourceManager.GetString("InvalidEmitDefaultAnnotation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to InvalidEnumBaseType: {0}, {1}, {2}, {3}.
        /// </summary>
        internal static string InvalidEnumBaseType {
            get {
                return ResourceManager.GetString("InvalidEnumBaseType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; in type &apos;{1}&apos; cannot have EnumMemberAttribute attribute Value set to null or empty string..
        /// </summary>
        internal static string InvalidEnumMemberValue {
            get {
                return ResourceManager.GetString("InvalidEnumMemberValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid enum value &apos;{0}&apos; cannot be deserialized into type &apos;{1}&apos;. Ensure that the necessary enum values are present and are marked with EnumMemberAttribute attribute if the type has DataContractAttribute attribute..
        /// </summary>
        internal static string InvalidEnumValueOnRead {
            get {
                return ResourceManager.GetString("InvalidEnumValueOnRead", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enum value &apos;{0}&apos; is invalid for type &apos;{1}&apos; and cannot be serialized. Ensure that the necessary enum values are present and are marked with EnumMemberAttribute attribute if the type has DataContractAttribute attribute..
        /// </summary>
        internal static string InvalidEnumValueOnWrite {
            get {
                return ResourceManager.GetString("InvalidEnumValueOnWrite", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot have MethodName on XmlSchemaProviderAttribute attribute set to null or empty string. .
        /// </summary>
        internal static string InvalidGetSchemaMethod {
            get {
                return ResourceManager.GetString("InvalidGetSchemaMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CLR namespace &apos;{0}&apos; cannot have ContractNamespace set to null..
        /// </summary>
        internal static string InvalidGlobalDataContractNamespace {
            get {
                return ResourceManager.GetString("InvalidGlobalDataContractNamespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The inclusive namespace prefix collection cannot contain null as one of the items..
        /// </summary>
        internal static string InvalidInclusivePrefixListCollection {
            get {
                return ResourceManager.GetString("InvalidInclusivePrefixListCollection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot import type &apos;{0}&apos; in namespace &apos;{1}&apos; as its base type because derived type is ISerializable but the base type is not ISerializable..
        /// </summary>
        internal static string InvalidISerializableDerivation {
            get {
                return ResourceManager.GetString("InvalidISerializableDerivation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to It is an invalid dictionary type. Element &apos;{0}&apos; must reference a complex type containing a sequence with two required elements. Either fix the schema or remove the IsDictionary annotation..
        /// </summary>
        internal static string InvalidKeyValueType {
            get {
                return ResourceManager.GetString("InvalidKeyValueType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to It is an invalid dictionary type since element &apos;{0}&apos; references a type from a different namespace &apos;{1}&apos;. Either fix the schema or remove the IsDictionary annotation..
        /// </summary>
        internal static string InvalidKeyValueTypeNamespace {
            get {
                return ResourceManager.GetString("InvalidKeyValueTypeNamespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The empty string is not a valid local name..
        /// </summary>
        internal static string InvalidLocalNameEmpty {
            get {
                return ResourceManager.GetString("InvalidLocalNameEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}.{1}&apos; cannot be serialized since it is neither a field nor a property, and therefore cannot be marked with the DataMemberAttribute attribute. Remove the DataMemberAttribute attribute from the &apos;{1}&apos; member..
        /// </summary>
        internal static string InvalidMember {
            get {
                return ResourceManager.GetString("InvalidMember", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method &apos;{0}.{1}()&apos; returns a non-null value. The return value must be null since IsAny.
        /// </summary>
        internal static string InvalidNonNullReturnValueByIsAny {
            get {
                return ResourceManager.GetString("InvalidNonNullReturnValueByIsAny", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to InvalidPrimitiveType: {0}.
        /// </summary>
        internal static string InvalidPrimitiveType {
            get {
                return ResourceManager.GetString("InvalidPrimitiveType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; is not a valid serializable type..
        /// </summary>
        internal static string InvalidPrimitiveType_Serialization {
            get {
                return ResourceManager.GetString("InvalidPrimitiveType_Serialization", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method &apos;{0}.GetSchema()&apos; must return a schema with a valid Id..
        /// </summary>
        internal static string InvalidReturnSchemaOnGetSchemaMethod {
            get {
                return ResourceManager.GetString("InvalidReturnSchemaOnGetSchemaMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method &apos;{0}.{1}()&apos; returns &apos;{2}&apos;. The return type must be compatible with &apos;{3}&apos;..
        /// </summary>
        internal static string InvalidReturnTypeOnGetSchemaMethod {
            get {
                return ResourceManager.GetString("InvalidReturnTypeOnGetSchemaMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid Size &apos;{0}&apos;. Must be non-negative integer..
        /// </summary>
        internal static string InvalidSizeDefinition {
            get {
                return ResourceManager.GetString("InvalidSizeDefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An internal error has occurred. ExtensionDataReader is in an invalid state..
        /// </summary>
        internal static string InvalidStateInExtensionDataReader {
            get {
                return ResourceManager.GetString("InvalidStateInExtensionDataReader", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XML data contract Name for type &apos;{0}&apos; cannot be set to null or empty string..
        /// </summary>
        internal static string InvalidXmlDataContractName {
            get {
                return ResourceManager.GetString("InvalidXmlDataContractName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The XML encountered when deserializing extension data is invalid..
        /// </summary>
        internal static string InvalidXmlDeserializingExtensionData {
            get {
                return ResourceManager.GetString("InvalidXmlDeserializingExtensionData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid Id &apos;{0}&apos;. Must not be null or empty..
        /// </summary>
        internal static string InvalidXsIdDefinition {
            get {
                return ResourceManager.GetString("InvalidXsIdDefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid Ref &apos;{0}&apos;. Must not be null or empty..
        /// </summary>
        internal static string InvalidXsRefDefinition {
            get {
                return ResourceManager.GetString("InvalidXsRefDefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A null value cannot be serialized at the top level for IXmlSerializable root type &apos;{0}&apos; since its IsAny setting is &apos;true&apos;. This type must write all its contents including the root element. Verify that the IXmlSerializable implementation is correct..
        /// </summary>
        internal static string IsAnyCannotBeNull {
            get {
                return ResourceManager.GetString("IsAnyCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An object of type &apos;{0}&apos; cannot be serialized at the top level for IXmlSerializable root type &apos;{1}&apos; since its IsAny setting is &apos;true&apos;. This type must write all its contents including the root element. Verify that the IXmlSerializable implementation is correct..
        /// </summary>
        internal static string IsAnyCannotBeSerializedAsDerivedType {
            get {
                return ResourceManager.GetString("IsAnyCannotBeSerializedAsDerivedType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot specify an XmlRootAttribute attribute because its IsAny setting is &apos;true&apos;. This type must write all its contents including the root element. Verify that the IXmlSerializable implementation is correct..
        /// </summary>
        internal static string IsAnyCannotHaveXmlRoot {
            get {
                return ResourceManager.GetString("IsAnyCannotHaveXmlRoot", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to IsAny not supported by NetDataContractSerializer: {0}.
        /// </summary>
        internal static string IsAnyNotSupportedByNetDataContractSerializer {
            get {
                return ResourceManager.GetString("IsAnyNotSupportedByNetDataContractSerializer", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is an invalid value for IsDictionary annotation. {1}.
        /// </summary>
        internal static string IsDictionaryFormattedIncorrectly {
            get {
                return ResourceManager.GetString("IsDictionaryFormattedIncorrectly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; has set its ISerializable assembly name to &quot;0&quot;. &quot;0&quot; is an invalid assembly name. Consider using the full name of mscorlib if you would like your type to be deserialized in that assembly..
        /// </summary>
        internal static string ISerializableAssemblyNameSetToZero {
            get {
                return ResourceManager.GetString("ISerializableAssemblyNameSetToZero", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot be ISerializable and have DataContractAttribute attribute..
        /// </summary>
        internal static string ISerializableCannotHaveDataContract {
            get {
                return ResourceManager.GetString("ISerializableCannotHaveDataContract", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Its root sequence contains more than one particle..
        /// </summary>
        internal static string ISerializableContainsMoreThanOneItems {
            get {
                return ResourceManager.GetString("ISerializableContainsMoreThanOneItems", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Derived ISerializable types cannot contain any particles..
        /// </summary>
        internal static string ISerializableDerivedContainsOneOrMoreItems {
            get {
                return ResourceManager.GetString("ISerializableDerivedContainsOneOrMoreItems", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to It does not contain root sequence with a wildcard element &lt;any&gt;..
        /// </summary>
        internal static string ISerializableDoesNotContainAny {
            get {
                return ResourceManager.GetString("ISerializableDoesNotContainAny", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to It does not reference attribute &apos;{0}&apos; from namespace &apos;{1}&apos;. .
        /// </summary>
        internal static string ISerializableMustRefFactoryTypeAttribute {
            get {
                return ResourceManager.GetString("ISerializableMustRefFactoryTypeAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ISerializable type &apos;{0}&apos; in namespace &apos;{1}&apos; cannot be imported. &apos;{2}&apos;.
        /// </summary>
        internal static string ISerializableTypeCannotBeImported {
            get {
                return ResourceManager.GetString("ISerializableTypeCannotBeImported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;maxOccurs&apos; on the wildcard element must be &apos;{0}&apos;..
        /// </summary>
        internal static string ISerializableWildcardMaxOccursMustBe {
            get {
                return ResourceManager.GetString("ISerializableWildcardMaxOccursMustBe", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;minOccurs&apos; on the wildcard element must be &apos;{0}&apos;..
        /// </summary>
        internal static string ISerializableWildcardMinOccursMustBe {
            get {
                return ResourceManager.GetString("ISerializableWildcardMinOccursMustBe", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Namespace on the wildcard element must be &apos;{0}&apos;..
        /// </summary>
        internal static string ISerializableWildcardNamespaceInvalid {
            get {
                return ResourceManager.GetString("ISerializableWildcardNamespaceInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ProcessContents on the wildcard element must be &apos;{0}&apos;..
        /// </summary>
        internal static string ISerializableWildcardProcessContentsInvalid {
            get {
                return ResourceManager.GetString("ISerializableWildcardProcessContentsInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An internal error has occurred. &apos;{0}&apos; is not assignable from &apos;{1}&apos; - error generating code for serialization..
        /// </summary>
        internal static string IsNotAssignableFrom {
            get {
                return ResourceManager.GetString("IsNotAssignableFrom", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to IsReferenceGetOnlyCollectionsNotSupported: {0}, {1}.
        /// </summary>
        internal static string IsReferenceGetOnlyCollectionsNotSupported {
            get {
                return ResourceManager.GetString("IsReferenceGetOnlyCollectionsNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}.{1}&apos; has the IsRequired setting of &apos;{2}. However, &apos;{0}&apos; has the IsReference setting of &apos;{2}&apos;, because either it is set explicitly, or it is derived from a base class. Set IsRequired on &apos;{0}.{1}&apos; to false, or disable IsReference on &apos;{0}&apos;..
        /// </summary>
        internal static string IsRequiredDataMemberOnIsReferenceDataContractType {
            get {
                return ResourceManager.GetString("IsRequiredDataMemberOnIsReferenceDataContractType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is an invalid value for IsValueType annotation. {1}.
        /// </summary>
        internal static string IsValueTypeFormattedIncorrectly {
            get {
                return ResourceManager.GetString("IsValueTypeFormattedIncorrectly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot be IXmlSerializable and have CollectionDataContractAttribute attribute..
        /// </summary>
        internal static string IXmlSerializableCannotHaveCollectionDataContract {
            get {
                return ResourceManager.GetString("IXmlSerializableCannotHaveCollectionDataContract", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot be IXmlSerializable and have DataContractAttribute attribute..
        /// </summary>
        internal static string IXmlSerializableCannotHaveDataContract {
            get {
                return ResourceManager.GetString("IXmlSerializableCannotHaveDataContract", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This method cannot be called from IXmlSerializable implementations..
        /// </summary>
        internal static string IXmlSerializableIllegalOperation {
            get {
                return ResourceManager.GetString("IXmlSerializableIllegalOperation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to IXmlSerializable.WriteXml method of type &apos;{0}&apos; did not close all open tags. Verify that the IXmlSerializable implementation is correct..
        /// </summary>
        internal static string IXmlSerializableMissingEndElements {
            get {
                return ResourceManager.GetString("IXmlSerializableMissingEndElements", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to IXmlSerializable Type &apos;{0}&apos; must have default constructor..
        /// </summary>
        internal static string IXmlSerializableMustHaveDefaultConstructor {
            get {
                return ResourceManager.GetString("IXmlSerializableMustHaveDefaultConstructor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to IXmlSerializable.WriteXml method of type &apos;{0}&apos; attempted to close too many tags.  Verify that the IXmlSerializable implementation is correct..
        /// </summary>
        internal static string IXmlSerializableWritePastSubTree {
            get {
                return ResourceManager.GetString("IXmlSerializableWritePastSubTree", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot write attribute with local name &apos;{0}&apos; multiple times..
        /// </summary>
        internal static string JsonAttributeAlreadyWritten {
            get {
                return ResourceManager.GetString("JsonAttributeAlreadyWritten", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to WriteStartElement must be called at least once before WriteStartAttribute may be called..
        /// </summary>
        internal static string JsonAttributeMustHaveElement {
            get {
                return ResourceManager.GetString("JsonAttributeMustHaveElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot write a CLR value that maps to number, array, object, true, false or null in JSON after a string value has been written..
        /// </summary>
        internal static string JsonCannotWriteStandaloneTextAfterQuotedText {
            get {
                return ResourceManager.GetString("JsonCannotWriteStandaloneTextAfterQuotedText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Attempted to write text after writing attribute type=&apos;{0}&apos;. Text may be written only after the attributes type=&apos;number&apos;, type=&apos;boolean&apos;, or type=&apos;string&apos;..
        /// </summary>
        internal static string JsonCannotWriteTextAfterNonTextAttribute {
            get {
                return ResourceManager.GetString("JsonCannotWriteTextAfterNonTextAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DateTime values that are greater than DateTime.MaxValue or smaller than DateTime.MinValue when converted to UTC cannot be serialized to JSON..
        /// </summary>
        internal static string JsonDateTimeOutOfRange {
            get {
                return ResourceManager.GetString("JsonDateTimeOutOfRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be deserialized because the data member &apos;{1}&apos; was found more than once in the input..
        /// </summary>
        internal static string JsonDuplicateMemberInInput {
            get {
                return ResourceManager.GetString("JsonDuplicateMemberInInput", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; is not serializable with DataContractJsonSerializer because the data member &apos;{1}&apos; is duplicated in its type hierarchy..
        /// </summary>
        internal static string JsonDuplicateMemberNames {
            get {
                return ResourceManager.GetString("JsonDuplicateMemberNames", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encoding not supported in JSON. UTF-8, Unicode, and BigEndianUnicode are the only supported encodings..
        /// </summary>
        internal static string JsonEncodingNotSupported {
            get {
                return ResourceManager.GetString("JsonEncodingNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encountered unexpected character &apos;{0}&apos;..
        /// </summary>
        internal static string JsonEncounteredUnexpectedCharacter {
            get {
                return ResourceManager.GetString("JsonEncounteredUnexpectedCharacter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No corresponding start element is open..
        /// </summary>
        internal static string JsonEndElementNoOpenNodes {
            get {
                return ResourceManager.GetString("JsonEndElementNoOpenNodes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expected encoding &apos;{0}&apos; does not match the actual encoding &apos;{1}&apos;..
        /// </summary>
        internal static string JsonExpectedEncoding {
            get {
                return ResourceManager.GetString("JsonExpectedEncoding", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid byte encoding..
        /// </summary>
        internal static string JsonInvalidBytes {
            get {
                return ResourceManager.GetString("JsonInvalidBytes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Attempted to write an attribute &apos;{0}&apos;=&apos;{1}&apos; after writing the attribute with local name &apos;{2}&apos;. The attribute with local name &apos;{2}&apos; is only valid with an attribute &apos;{0}&apos;=&apos;{3}&apos;..
        /// </summary>
        internal static string JsonInvalidDataTypeSpecifiedForServerType {
            get {
                return ResourceManager.GetString("JsonInvalidDataTypeSpecifiedForServerType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DateTime content &apos;{0}&apos; does not start with &apos;{1}&apos; and end with &apos;{2}&apos; as required for JSON..
        /// </summary>
        internal static string JsonInvalidDateTimeString {
            get {
                return ResourceManager.GetString("JsonInvalidDateTimeString", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Characters with hexadecimal values 0xFFFE and 0xFFFF are not valid..
        /// </summary>
        internal static string JsonInvalidFFFE {
            get {
                return ResourceManager.GetString("JsonInvalidFFFE", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encountered unexpected element local name &apos;{0}&apos; for item in collection. &apos;{1}&apos; is the only valid local name for elements in a collection..
        /// </summary>
        internal static string JsonInvalidItemNameForArrayElement {
            get {
                return ResourceManager.GetString("JsonInvalidItemNameForArrayElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The empty string is not a valid local name in JSON..
        /// </summary>
        internal static string JsonInvalidLocalNameEmpty {
            get {
                return ResourceManager.GetString("JsonInvalidLocalNameEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot write content while an attribute is being written..
        /// </summary>
        internal static string JsonInvalidMethodBetweenStartEndAttribute {
            get {
                return ResourceManager.GetString("JsonInvalidMethodBetweenStartEndAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encountered invalid root element name &apos;{0}&apos;. &apos;{1}&apos; is the only allowed root element name..
        /// </summary>
        internal static string JsonInvalidRootElementName {
            get {
                return ResourceManager.GetString("JsonInvalidRootElementName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to WriteStartElement can be called at only the start of a document or immediately after calling WriteEndElement..
        /// </summary>
        internal static string JsonInvalidStartElementCall {
            get {
                return ResourceManager.GetString("JsonInvalidStartElementCall", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; cannot be called while WriteState is &apos;{1}&apos;..
        /// </summary>
        internal static string JsonInvalidWriteState {
            get {
                return ResourceManager.GetString("JsonInvalidWriteState", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This XmlDictionaryWriter implementation does not support the &apos;{0}&apos; method..
        /// </summary>
        internal static string JsonMethodNotSupported {
            get {
                return ResourceManager.GetString("JsonMethodNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This XmlDictionaryWriter implementation does not support the writing of multiple root elements..
        /// </summary>
        internal static string JsonMultipleRootElementsNotAllowedOnWriter {
            get {
                return ResourceManager.GetString("JsonMultipleRootElementsNotAllowedOnWriter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You must write an attribute &apos;{0}&apos;=&apos;{1}&apos; after writing the attribute with local name &apos;{2}&apos;..
        /// </summary>
        internal static string JsonMustSpecifyDataType {
            get {
                return ResourceManager.GetString("JsonMustSpecifyDataType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To write attribute values with this XmlDictionaryWriter implementation, you must write either string or char[] values..
        /// </summary>
        internal static string JsonMustUseWriteStringForWritingAttributeValues {
            get {
                return ResourceManager.GetString("JsonMustUseWriteStringForWritingAttributeValues", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encountered unexpected namespace &apos;{0}&apos;. The namespace must be empty..
        /// </summary>
        internal static string JsonNamespaceMustBeEmpty {
            get {
                return ResourceManager.GetString("JsonNamespaceMustBeEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Nested arrays are not supported..
        /// </summary>
        internal static string JsonNestedArraysNotSupported {
            get {
                return ResourceManager.GetString("JsonNestedArraysNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to WriteStartElement cannot be called immediately after WriteStartElement without writing the &apos;type&apos;=&apos;array&apos; or &apos;type=&apos;object&apos; attribute..
        /// </summary>
        internal static string JsonNodeTypeArrayOrObjectNotSpecified {
            get {
                return ResourceManager.GetString("JsonNodeTypeArrayOrObjectNotSpecified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There is no open attribute..
        /// </summary>
        internal static string JsonNoMatchingStartAttribute {
            get {
                return ResourceManager.GetString("JsonNoMatchingStartAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified offset exceeds the buffer size ({0} bytes)..
        /// </summary>
        internal static string JsonOffsetExceedsBufferSize {
            get {
                return ResourceManager.GetString("JsonOffsetExceedsBufferSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be deserialized because the required data member &apos;{1}&apos; was not found..
        /// </summary>
        internal static string JsonOneRequiredMemberNotFound {
            get {
                return ResourceManager.GetString("JsonOneRequiredMemberNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected character &apos;{0}&apos;. &apos;{1}&apos; can write only whitespace characters..
        /// </summary>
        internal static string JsonOnlyWhitespace {
            get {
                return ResourceManager.GetString("JsonOnlyWhitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot call {0} while an attribute is being written..
        /// </summary>
        internal static string JsonOpenAttributeMustBeClosedFirst {
            get {
                return ResourceManager.GetString("JsonOpenAttributeMustBeClosedFirst", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encountered unexpected prefix &apos;{0}&apos;. The prefix must be null or empty..
        /// </summary>
        internal static string JsonPrefixMustBeNullOrEmpty {
            get {
                return ResourceManager.GetString("JsonPrefixMustBeNullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be deserialized because the required data members &apos;{1}&apos; were not found..
        /// </summary>
        internal static string JsonRequiredMembersNotFound {
            get {
                return ResourceManager.GetString("JsonRequiredMembersNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Attempted to write an attribute with local name &apos;{0}&apos; after writing the attribute &apos;{1}&apos;=&apos;{2}&apos;. An attribute with local name &apos;{0}&apos; may be written only after writing the attribute &apos;{1}&apos;=&apos;{3}&apos;..
        /// </summary>
        internal static string JsonServerTypeSpecifiedForInvalidDataType {
            get {
                return ResourceManager.GetString("JsonServerTypeSpecifiedForInvalidDataType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified size exceeds the remaining buffer space (&apos;{0}&apos; bytes)..
        /// </summary>
        internal static string JsonSizeExceedsRemainingBufferSpace {
            get {
                return ResourceManager.GetString("JsonSizeExceedsRemainingBufferSpace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataContractJsonSerializer does not support objects of type &apos;{0}&apos;..
        /// </summary>
        internal static string JsonTypeNotSupportedByDataContractJsonSerializer {
            get {
                return ResourceManager.GetString("JsonTypeNotSupportedByDataContractJsonSerializer", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encountered unexpected attribute local name &apos;{0}&apos;. &apos;type&apos; and &apos;__type&apos; are the only allowed local names for attributes. &apos;type&apos; can be used to influence how data is written; its valid values are &apos;object&apos;, &apos;string&apos;, &apos;number&apos;, &apos;null&apos;, &apos;boolean&apos;, and &apos;array&apos;. &apos;__type&apos; can be used to provide type hint information to the writer..
        /// </summary>
        internal static string JsonUnexpectedAttributeLocalName {
            get {
                return ResourceManager.GetString("JsonUnexpectedAttributeLocalName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The attribute &apos;type&apos; must have one of the following strings as its values: &apos;string&apos;, &apos;number&apos;, &apos;array&apos;, &apos;object&apos;, &apos;null&apos;, or &apos;boolean&apos;.  Encountered unexpected value &apos;{0}&apos;.
        /// </summary>
        internal static string JsonUnexpectedAttributeValue {
            get {
                return ResourceManager.GetString("JsonUnexpectedAttributeValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected end of file..
        /// </summary>
        internal static string JsonUnexpectedEndOfFile {
            get {
                return ResourceManager.GetString("JsonUnexpectedEndOfFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type &apos;{0}&apos; cannot be serialized to JSON because its IsReference setting is &apos;{1}&apos;. The JSON format does not support references because there is no standardized format for representing references. To enable serialization, disable the IsReference setting on the type or an appropriate parent class of the type..
        /// </summary>
        internal static string JsonUnsupportedForIsReference {
            get {
                return ResourceManager.GetString("JsonUnsupportedForIsReference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To write JSON arrays, use XML writer methods to write the attribute type=&apos;array&apos; followed by methods like WriteStartElement (with the local name &apos;item&apos;), WriteAttributeString, and WriteEndElement to write the JSON array items..
        /// </summary>
        internal static string JsonWriteArrayNotSupported {
            get {
                return ResourceManager.GetString("JsonWriteArrayNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The writer is closed..
        /// </summary>
        internal static string JsonWriterClosed {
            get {
                return ResourceManager.GetString("JsonWriterClosed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XML declaration can only be written at the beginning of the document..
        /// </summary>
        internal static string JsonXmlInvalidDeclaration {
            get {
                return ResourceManager.GetString("JsonXmlInvalidDeclaration", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Processing instructions (other than the XML declaration) are not supported..
        /// </summary>
        internal static string JsonXmlProcessingInstructionNotSupported {
            get {
                return ResourceManager.GetString("JsonXmlProcessingInstructionNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The dictionary of type &apos;{0}&apos; cannot be deserialized as a simple dictionary because its key type &apos;{1}&apos; does not have a public static Parse method..
        /// </summary>
        internal static string KeyTypeCannotBeParsedInSimpleDictionary {
            get {
                return ResourceManager.GetString("KeyTypeCannotBeParsedInSimpleDictionary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method name specified by KnownTypeAttribute attribute on type &apos;{0}&apos; cannot be the empty string..
        /// </summary>
        internal static string KnownTypeAttributeEmptyString {
            get {
                return ResourceManager.GetString("KnownTypeAttributeEmptyString", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method specified by KnownTypeAttribute attribute on type &apos;{0}&apos; returned null..
        /// </summary>
        internal static string KnownTypeAttributeMethodNull {
            get {
                return ResourceManager.GetString("KnownTypeAttributeMethodNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to KnownTypeAttribute attribute on type &apos;{0}&apos; contains no data..
        /// </summary>
        internal static string KnownTypeAttributeNoData {
            get {
                return ResourceManager.GetString("KnownTypeAttributeNoData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos;: If a KnownTypeAttribute attribute specifies a method it must be the only KnownTypeAttribute attribute on that type..
        /// </summary>
        internal static string KnownTypeAttributeOneScheme {
            get {
                return ResourceManager.GetString("KnownTypeAttributeOneScheme", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to KnownTypeAttribute attribute on type &apos;{0}&apos; specifies a method named &apos;{1}&apos; to provide known types. The return type of this method is invalid because it is not assignable to IEnumerable&lt;Type&gt;. Ensure that the method exists and has a valid signature..
        /// </summary>
        internal static string KnownTypeAttributeReturnType {
            get {
                return ResourceManager.GetString("KnownTypeAttributeReturnType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to KnownTypeAttribute attribute on type &apos;{1}&apos; specifies a method named &apos;{0}&apos; to provide known types. Static method &apos;{0}()&apos; was not found on this type. Ensure that the method exists and is marked as static..
        /// </summary>
        internal static string KnownTypeAttributeUnknownMethod {
            get {
                return ResourceManager.GetString("KnownTypeAttributeUnknownMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method specified by KnownTypeAttribute attribute on type &apos;{0}&apos; does not expose valid types..
        /// </summary>
        internal static string KnownTypeAttributeValidMethodTypes {
            get {
                return ResourceManager.GetString("KnownTypeAttributeValidMethodTypes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to KnownTypeConfigClosedGenericDeclared: {0}.
        /// </summary>
        internal static string KnownTypeConfigClosedGenericDeclared {
            get {
                return ResourceManager.GetString("KnownTypeConfigClosedGenericDeclared", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum array length ({0}) has been exceeded while reading XML data for array of type &apos;{1}&apos;..
        /// </summary>
        internal static string MaxArrayLengthExceeded {
            get {
                return ResourceManager.GetString("MaxArrayLengthExceeded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; does not have a static method &apos;{1}&apos; that takes a parameter of type &apos;System.Xml.Schema.XmlSchemaSet&apos; as specified by the XmlSchemaProviderAttribute attribute..
        /// </summary>
        internal static string MissingGetSchemaMethod {
            get {
                return ResourceManager.GetString("MissingGetSchemaMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Schema type &apos;{0}&apos; returned by CLR type &apos;{1}&apos; is not found in the XmlSchemaSet..
        /// </summary>
        internal static string MissingSchemaType {
            get {
                return ResourceManager.GetString("MissingSchemaType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Complex type with mixed content is not supported..
        /// </summary>
        internal static string MixedContentNotSupported {
            get {
                return ResourceManager.GetString("MixedContentNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid XML encountered. The same Id value &apos;{0}&apos; is defined more than once. Multiple objects cannot be deserialized using the same Id..
        /// </summary>
        internal static string MultipleIdDefinition {
            get {
                return ResourceManager.GetString("MultipleIdDefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The root sequence must contain only local elements. Group ref, choice, any and nested sequences are not supported..
        /// </summary>
        internal static string MustContainOnlyLocalElements {
            get {
                return ResourceManager.GetString("MustContainOnlyLocalElements", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An internal error has occurred. No conversion is possible to &apos;{0}&apos; - error generating code for serialization..
        /// </summary>
        internal static string NoConversionPossibleTo {
            get {
                return ResourceManager.GetString("NoConversionPossibleTo", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Collection type &apos;{0}&apos; doesn&apos;t have default constructor..
        /// </summary>
        internal static string NoDefaultConstructorForCollection {
            get {
                return ResourceManager.GetString("NoDefaultConstructorForCollection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No get method for property &apos;{1}&apos; in type &apos;{0}&apos;..
        /// </summary>
        internal static string NoGetMethodForProperty {
            get {
                return ResourceManager.GetString("NoGetMethodForProperty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Type &apos;{0}&apos; must have a parameterless constructor..
        /// </summary>
        internal static string NonAttributedSerializableTypesMustHaveDefaultConstructor {
            get {
                return ResourceManager.GetString("NonAttributedSerializableTypesMustHaveDefaultConstructor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}.{1}&apos; is not marked with OptionalFieldAttribute, thus indicating that it must be serialized. However, &apos;{0}&apos; derives from a class marked with DataContractAttribute and an IsReference setting of &apos;{2}&apos;. It is not possible to have required data members on IsReference classes. Either decorate &apos;{0}.{1}&apos; with OptionalFieldAttribute, or disable the IsReference setting on the appropriate parent class..
        /// </summary>
        internal static string NonOptionalFieldMemberOnIsReferenceSerializableType {
            get {
                return ResourceManager.GetString("NonOptionalFieldMemberOnIsReferenceSerializableType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No set method for property &apos;{1}&apos; in type &apos;{0}&apos;..
        /// </summary>
        internal static string NoSetMethodForProperty {
            get {
                return ResourceManager.GetString("NoSetMethodForProperty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to One of the known types provided to the serializer via &apos;{0}&apos; argument was invalid because it was null. All known types specified must be non-null values..
        /// </summary>
        internal static string NullKnownType {
            get {
                return ResourceManager.GetString("NullKnownType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The get-only collection of type &apos;{0}&apos; returned a null value.  The input stream contains collection items which cannot be added if the instance is null.  Consider initializing the collection either in the constructor of the object or in the getter..
        /// </summary>
        internal static string NullValueReturnedForGetOnlyCollection {
            get {
                return ResourceManager.GetString("NullValueReturnedForGetOnlyCollection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An internal error has occurred. Object table overflow. This could be caused by serializing or deserializing extremely large object graphs..
        /// </summary>
        internal static string ObjectTableOverflow {
            get {
                return ResourceManager.GetString("ObjectTableOverflow", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified offset exceeds the buffer size ({0} bytes)..
        /// </summary>
        internal static string OffsetExceedsBufferSize {
            get {
                return ResourceManager.GetString("OffsetExceedsBufferSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; does not have DataContractAttribute attribute and therefore cannot support IExtensibleDataObject. .
        /// </summary>
        internal static string OnlyDataContractTypesCanHaveExtensionData {
            get {
                return ResourceManager.GetString("OnlyDataContractTypesCanHaveExtensionData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid number of parameters to call method &apos;{0}&apos;. Expected &apos;{1}&apos; parameters, but &apos;{2}&apos; were provided..
        /// </summary>
        internal static string ParameterCountMismatch {
            get {
                return ResourceManager.GetString("ParameterCountMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to JsonObjectDataContract.ParseJsonNumber shouldn&apos;t return a TypeCode that we&apos;re not expecting..
        /// </summary>
        internal static string ParseJsonNumberReturnInvalidNumber {
            get {
                return ResourceManager.GetString("ParseJsonNumberReturnInvalidNumber", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection data contract type &apos;{0}&apos; cannot be deserialized because the method &apos;{1}&apos; is not public. Making the method public will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustCollectionContractAddMethodNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustCollectionContractAddMethodNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection data contract type &apos;{0}&apos; cannot be deserialized because it does not have a public parameterless constructor. Adding a public parameterless constructor will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustCollectionContractNoPublicConstructor {
            get {
                return ResourceManager.GetString("PartialTrustCollectionContractNoPublicConstructor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection data contract type &apos;{0}&apos; cannot be deserialized because it does not have a public parameterless constructor. Adding a public parameterless constructor will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustCollectionContractTypeNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustCollectionContractTypeNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be serialized because the member &apos;{1}&apos; is not public. Making the member public will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustDataContractFieldGetNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustDataContractFieldGetNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be deserialized because the member &apos;{1}&apos; is not public. Making the member public will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustDataContractFieldSetNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustDataContractFieldSetNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be deserialized because the OnDeserialized method &apos;{1}&apos; is not public. Making the method public will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustDataContractOnDeserializedNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustDataContractOnDeserializedNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be deserialized because the OnDeserializing method &apos;{1}&apos; is not public. Making the method public will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustDataContractOnDeserializingNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustDataContractOnDeserializingNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be serialized because the OnSerialized method &apos;{1}&apos; is not public. Making the method public will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustDataContractOnSerializedNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustDataContractOnSerializedNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be serialized because the OnSerializing method &apos;{1}&apos; is not public. Making the method public will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustDataContractOnSerializingNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustDataContractOnSerializingNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be serialized because the property &apos;{1}&apos; does not have a public getter. Adding a public getter will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustDataContractPropertyGetNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustDataContractPropertyGetNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; cannot be deserialized because the property &apos;{1}&apos; does not have a public setter. Adding a public setter will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustDataContractPropertySetNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustDataContractPropertySetNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data contract type &apos;{0}&apos; is not serializable because it is not public. Making the type public will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustDataContractTypeNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustDataContractTypeNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to PartialTrustISerializableNoPublicConstructor: {0}.
        /// </summary>
        internal static string PartialTrustISerializableNoPublicConstructor {
            get {
                return ResourceManager.GetString("PartialTrustISerializableNoPublicConstructor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The IXmlSerializable type &apos;{0}&apos; is not serializable in partial trust because it is not public. Adding a public parameterless constructor will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustIXmlSerializableTypeNotPublic {
            get {
                return ResourceManager.GetString("PartialTrustIXmlSerializableTypeNotPublic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The IXmlSerializable type &apos;{0}&apos; cannot be deserialized because it does not have a public parameterless constructor. Adding a public parameterless constructor will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustIXmlSerialzableNoPublicConstructor {
            get {
                return ResourceManager.GetString("PartialTrustIXmlSerialzableNoPublicConstructor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type &apos;{0}&apos; cannot be deserialized because it does not have a public parameterless constructor. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications..
        /// </summary>
        internal static string PartialTrustNonAttributedSerializableTypeNoPublicConstructor {
            get {
                return ResourceManager.GetString("PartialTrustNonAttributedSerializableTypeNoPublicConstructor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The canonicalization process is not supported on this platform..
        /// </summary>
        internal static string PlatformNotSupported_Canonicalization {
            get {
                return ResourceManager.GetString("PlatformNotSupported_Canonicalization", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The implementation of the function requires System.Runtime.Serialization.IDataContractSurrogate which is not supported on this platform..
        /// </summary>
        internal static string PlatformNotSupported_IDataContractSurrogate {
            get {
                return ResourceManager.GetString("PlatformNotSupported_IDataContractSurrogate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Message Transmission Optimization Mechanism (MTOM) message encoding is not supported on this platform..
        /// </summary>
        internal static string PlatformNotSupported_MtomEncoding {
            get {
                return ResourceManager.GetString("PlatformNotSupported_MtomEncoding", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to System.Runtime.Serialization.NetDataContractSerializer is not supported on this platform..
        /// </summary>
        internal static string PlatformNotSupported_NetDataContractSerializer {
            get {
                return ResourceManager.GetString("PlatformNotSupported_NetDataContractSerializer", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The implementation of the function requires System.Runtime.Serialization.SchemaImporter which is not supported on this platform..
        /// </summary>
        internal static string PlatformNotSupported_SchemaImporter {
            get {
                return ResourceManager.GetString("PlatformNotSupported_SchemaImporter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot find a path to the member when generating the XPath query..
        /// </summary>
        internal static string QueryGeneratorPathToMemberNotFound {
            get {
                return ResourceManager.GetString("QueryGeneratorPathToMemberNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot copy XmlDictionaryReaderQuotas. Target is readonly..
        /// </summary>
        internal static string QuotaCopyReadOnly {
            get {
                return ResourceManager.GetString("QuotaCopyReadOnly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; quota is readonly..
        /// </summary>
        internal static string QuotaIsReadOnly {
            get {
                return ResourceManager.GetString("QuotaIsReadOnly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Quota must be a positive value..
        /// </summary>
        internal static string QuotaMustBePositive {
            get {
                return ResourceManager.GetString("QuotaMustBePositive", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ReadOnlyClassDeserialization: {0}.
        /// </summary>
        internal static string ReadOnlyClassDeserialization {
            get {
                return ResourceManager.GetString("ReadOnlyClassDeserialization", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ReadOnlyCollectionDeserialization: {0}.
        /// </summary>
        internal static string ReadOnlyCollectionDeserialization {
            get {
                return ResourceManager.GetString("ReadOnlyCollectionDeserialization", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; is a recursive collection data contract which is not supported. Consider modifying the definition of collection &apos;{0}&apos; to remove references to itself..
        /// </summary>
        internal static string RecursiveCollectionType {
            get {
                return ResourceManager.GetString("RecursiveCollectionType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Redefine is not supported..
        /// </summary>
        internal static string RedefineNotSupported {
            get {
                return ResourceManager.GetString("RedefineNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ReferencedCollectionTypesCannotContainNull.
        /// </summary>
        internal static string ReferencedCollectionTypesCannotContainNull {
            get {
                return ResourceManager.GetString("ReferencedCollectionTypesCannotContainNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to (matching).
        /// </summary>
        internal static string ReferencedTypeMatchingMessage {
            get {
                return ResourceManager.GetString("ReferencedTypeMatchingMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to (not matching).
        /// </summary>
        internal static string ReferencedTypeNotMatchingMessage {
            get {
                return ResourceManager.GetString("ReferencedTypeNotMatchingMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ReferencedTypesCannotContainNull.
        /// </summary>
        internal static string ReferencedTypesCannotContainNull {
            get {
                return ResourceManager.GetString("ReferencedTypesCannotContainNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member {0} in type {1} cannot be serialized. This exception is usually caused by trying to use a null value where a null value is not allowed. The &apos;{0}&apos; member is set to its default value (usually null or zero). The member&apos;s EmitDefault setting is &apos;false&apos;, indicating that the member should not be serialized. However, the member&apos;s IsRequired setting is &apos;true&apos;, indicating that it must be serialized. This conflict cannot be resolved.  Consider setting &apos;{0}&apos; to a non-default value. Alternatively, you can change [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string RequiredMemberMustBeEmitted {
            get {
                return ResourceManager.GetString("RequiredMemberMustBeEmitted", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Only classes can be generated as ISerializable..
        /// </summary>
        internal static string RequiresClassDataContractToSetIsISerializable {
            get {
                return ResourceManager.GetString("RequiresClassDataContractToSetIsISerializable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An object of type &apos;{0}&apos; which derives from DataContractResolver returned false from its TryResolveType method when attempting to resolve the name for an object of type &apos;{1}&apos;, indicating that the resolution failed. Change the TryResolveType implementation to return true..
        /// </summary>
        internal static string ResolveTypeReturnedFalse {
            get {
                return ResourceManager.GetString("ResolveTypeReturnedFalse", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An object of type &apos;{0}&apos; which derives from DataContractResolver returned a null typeName or typeNamespace but not both from its TryResolveType method when attempting to resolve the name for an object of type &apos;{1}&apos;. Change the TryResolveType implementation to return non-null values, or to return null values for both typeName and typeNamespace in order to serialize as the declared type..
        /// </summary>
        internal static string ResolveTypeReturnedNull {
            get {
                return ResourceManager.GetString("ResolveTypeReturnedNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The root particle must be a sequence..
        /// </summary>
        internal static string RootParticleMustBeSequence {
            get {
                return ResourceManager.GetString("RootParticleMustBeSequence", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;maxOccurs&apos; on the root sequence must be 1..
        /// </summary>
        internal static string RootSequenceMaxOccursMustBe {
            get {
                return ResourceManager.GetString("RootSequenceMaxOccursMustBe", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;minOccurs&apos; on the root sequence must be 1..
        /// </summary>
        internal static string RootSequenceMustBeRequired {
            get {
                return ResourceManager.GetString("RootSequenceMustBeRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot be serialized, serialization code for the type is missing. Consult the SDK documentation for adding it as a root serialization type..
        /// </summary>
        internal static string SerializationCodeIsMissingForType {
            get {
                return ResourceManager.GetString("SerializationCodeIsMissingForType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The constructor with parameters (SerializationInfo, StreamingContext) is not found in ISerializable type &apos;{0}&apos;..
        /// </summary>
        internal static string SerializationInfo_ConstructorNotFound {
            get {
                return ResourceManager.GetString("SerializationInfo_ConstructorNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Complex types with simple content extension are not supported..
        /// </summary>
        internal static string SimpleContentNotSupported {
            get {
                return ResourceManager.GetString("SimpleContentNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Simple type restriction must specify a base type..
        /// </summary>
        internal static string SimpleTypeRestrictionDoesNotSpecifyBase {
            get {
                return ResourceManager.GetString("SimpleTypeRestrictionDoesNotSpecifyBase", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Simple types with &lt;union&gt; content are not supported..
        /// </summary>
        internal static string SimpleTypeUnionNotSupported {
            get {
                return ResourceManager.GetString("SimpleTypeUnionNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified size exceeds the remaining buffer space ({0} bytes)..
        /// </summary>
        internal static string SizeExceedsRemainingBufferSpace {
            get {
                return ResourceManager.GetString("SizeExceedsRemainingBufferSpace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid type specified. Type with name &apos;{0}&apos; not found in schema with namespace &apos;{1}&apos;..
        /// </summary>
        internal static string SpecifiedTypeNotFoundInSchema {
            get {
                return ResourceManager.GetString("SpecifiedTypeNotFoundInSchema", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Substitution group on element &apos;{0}&apos; is not supported..
        /// </summary>
        internal static string SubstitutionGroupOnElementNotSupported {
            get {
                return ResourceManager.GetString("SubstitutionGroupOnElementNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multi-dimensional arrays are not supported..
        /// </summary>
        internal static string SupportForMultidimensionalArraysNotPresent {
            get {
                return ResourceManager.GetString("SupportForMultidimensionalArraysNotPresent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to SurrogatesWithGetOnlyCollectionsNotSupported: {0}, {1}, {2}.
        /// </summary>
        internal static string SurrogatesWithGetOnlyCollectionsNotSupported {
            get {
                return ResourceManager.GetString("SurrogatesWithGetOnlyCollectionsNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using surrogates with get-only collection properties is not supported.  Consider removing the surrogate associated with &apos;{0}&apos;..
        /// </summary>
        internal static string SurrogatesWithGetOnlyCollectionsNotSupportedSerDeser {
            get {
                return ResourceManager.GetString("SurrogatesWithGetOnlyCollectionsNotSupportedSerDeser", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; has more than one CollectionDataContractAttribute attribute..
        /// </summary>
        internal static string TooManyCollectionContracts {
            get {
                return ResourceManager.GetString("TooManyCollectionContracts", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; has more than one DataContractAttribute attribute..
        /// </summary>
        internal static string TooManyDataContracts {
            get {
                return ResourceManager.GetString("TooManyDataContracts", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}.{1}&apos; has more than one DataMemberAttribute attribute..
        /// </summary>
        internal static string TooManyDataMembers {
            get {
                return ResourceManager.GetString("TooManyDataMembers", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}.{1}&apos; has more than one EnumMemberAttribute attribute..
        /// </summary>
        internal static string TooManyEnumMembers {
            get {
                return ResourceManager.GetString("TooManyEnumMembers", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member &apos;{0}.{1}&apos; has more than one IgnoreDataMemberAttribute attribute..
        /// </summary>
        internal static string TooManyIgnoreDataMemberAttributes {
            get {
                return ResourceManager.GetString("TooManyIgnoreDataMemberAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The global element found in the schema with same name references a different type &apos;{0}&apos; in namespace &apos;{1}&apos;. Data contract types must have the same name as their root element name. Consider removing the global element or changing its type..
        /// </summary>
        internal static string TopLevelElementRepresentsDifferentType {
            get {
                return ResourceManager.GetString("TopLevelElementRepresentsDifferentType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TypeCannotBeForwardedFrom: {0}, {1}, {2}.
        /// </summary>
        internal static string TypeCannotBeForwardedFrom {
            get {
                return ResourceManager.GetString("TypeCannotBeForwardedFrom", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; in namespace &apos;{1}&apos; cannot be imported. {2}.
        /// </summary>
        internal static string TypeCannotBeImported {
            get {
                return ResourceManager.GetString("TypeCannotBeImported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} Either change the schema so that the types can map to data contract types or use ImportXmlType or use a different serializer..
        /// </summary>
        internal static string TypeCannotBeImportedHowToFix {
            get {
                return ResourceManager.GetString("TypeCannotBeImportedHowToFix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TypeMustBeConcrete: {0}.
        /// </summary>
        internal static string TypeMustBeConcrete {
            get {
                return ResourceManager.GetString("TypeMustBeConcrete", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; cannot be serialized. Consider marking it with the DataContractAttribute attribute, and marking all of its members you want serialized with the DataMemberAttribute attribute. Alternatively, you can ensure that the type is public and has a parameterless constructor - all public members of the type will then be serialized, and no attributes will be required..
        /// </summary>
        internal static string TypeNotSerializable {
            get {
                return ResourceManager.GetString("TypeNotSerializable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Attributes must be optional and from namespace &apos;{0}&apos;..
        /// </summary>
        internal static string TypeShouldNotContainAttributes {
            get {
                return ResourceManager.GetString("TypeShouldNotContainAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An internal error has occurred. Unexpected contract type &apos;{0}&apos; for type &apos;{1}&apos; encountered..
        /// </summary>
        internal static string UnexpectedContractType {
            get {
                return ResourceManager.GetString("UnexpectedContractType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; &apos;{1}&apos; from namespace &apos;{2}&apos; is not expected. Expecting element &apos;{3}&apos;..
        /// </summary>
        internal static string UnexpectedElementExpectingElements {
            get {
                return ResourceManager.GetString("UnexpectedElementExpectingElements", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected end of file..
        /// </summary>
        internal static string UnexpectedEndOfFile {
            get {
                return ResourceManager.GetString("UnexpectedEndOfFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Internal Error: Unrecognized constant type {0}..
        /// </summary>
        internal static string UnknownConstantType {
            get {
                return ResourceManager.GetString("UnknownConstantType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; is not a valid XML type..
        /// </summary>
        internal static string UnknownXmlType {
            get {
                return ResourceManager.GetString("UnknownXmlType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value of this argument must fall within the range {0} to {1}..
        /// </summary>
        internal static string ValueMustBeInRange {
            get {
                return ResourceManager.GetString("ValueMustBeInRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value of this argument must be non-negative..
        /// </summary>
        internal static string ValueMustBeNonNegative {
            get {
                return ResourceManager.GetString("ValueMustBeNonNegative", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ValueType &apos;{0}&apos; cannot be null..
        /// </summary>
        internal static string ValueTypeCannotBeNull {
            get {
                return ResourceManager.GetString("ValueTypeCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Data contract &apos;{0}&apos; from namespace &apos;{1}&apos; is a value type and cannot have base contract &apos;{2}&apos; from namespace &apos;{3}&apos;..
        /// </summary>
        internal static string ValueTypeCannotHaveBaseType {
            get {
                return ResourceManager.GetString("ValueTypeCannotHaveBaseType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ValueType &apos;{0}&apos; cannot have id..
        /// </summary>
        internal static string ValueTypeCannotHaveId {
            get {
                return ResourceManager.GetString("ValueTypeCannotHaveId", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value type &apos;{0}&apos; cannot have the IsReference setting of &apos;{1}&apos;. Either change the setting to &apos;{2}&apos;, or remove it completely. .
        /// </summary>
        internal static string ValueTypeCannotHaveIsReference {
            get {
                return ResourceManager.GetString("ValueTypeCannotHaveIsReference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ValueType &apos;{0}&apos; cannot have ref to another object..
        /// </summary>
        internal static string ValueTypeCannotHaveRef {
            get {
                return ResourceManager.GetString("ValueTypeCannotHaveRef", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Array too small..
        /// </summary>
        internal static string XmlArrayTooSmall {
            get {
                return ResourceManager.GetString("XmlArrayTooSmall", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Array too small.  Length of available data must be at least {0}..
        /// </summary>
        internal static string XmlArrayTooSmallInput {
            get {
                return ResourceManager.GetString("XmlArrayTooSmallInput", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Array too small.  Must be able to hold at least {0}..
        /// </summary>
        internal static string XmlArrayTooSmallOutput {
            get {
                return ResourceManager.GetString("XmlArrayTooSmallOutput", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An asynchronous operation is already in progress..
        /// </summary>
        internal static string XmlAsyncIsRunningException {
            get {
                return ResourceManager.GetString("XmlAsyncIsRunningException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unrecognized Byte Order Mark..
        /// </summary>
        internal static string XmlBadBOM {
            get {
                return ResourceManager.GetString("XmlBadBOM", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Base64 encoded data expected. Found {0}..
        /// </summary>
        internal static string XmlBase64DataExpected {
            get {
                return ResourceManager.GetString("XmlBase64DataExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Canonicalization not started..
        /// </summary>
        internal static string XmlCanonicalizationNotStarted {
            get {
                return ResourceManager.GetString("XmlCanonicalizationNotStarted", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Canonicalization already started..
        /// </summary>
        internal static string XmlCanonicalizationStarted {
            get {
                return ResourceManager.GetString("XmlCanonicalizationStarted", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CData elements not valid at top level of an XML document..
        /// </summary>
        internal static string XmlCDATAInvalidAtTopLevel {
            get {
                return ResourceManager.GetString("XmlCDATAInvalidAtTopLevel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;]]&gt;&apos; not valid in text node content..
        /// </summary>
        internal static string XmlCloseCData {
            get {
                return ResourceManager.GetString("XmlCloseCData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value &apos;{0}&apos; cannot be represented with the type &apos;{1}&apos;..
        /// </summary>
        internal static string XmlConversionOverflow {
            get {
                return ResourceManager.GetString("XmlConversionOverflow", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An XML declaration with an encoding is required for all non-UTF8 documents..
        /// </summary>
        internal static string XmlDeclarationRequired {
            get {
                return ResourceManager.GetString("XmlDeclarationRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An XML declaration is required for all non-UTF8 documents..
        /// </summary>
        internal static string XmlDeclMissing {
            get {
                return ResourceManager.GetString("XmlDeclMissing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Version not found in XML declaration..
        /// </summary>
        internal static string XmlDeclMissingVersion {
            get {
                return ResourceManager.GetString("XmlDeclMissingVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No characters can appear before the XML declaration..
        /// </summary>
        internal static string XmlDeclNotFirst {
            get {
                return ResourceManager.GetString("XmlDeclNotFirst", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XmlDictionaryString IDs must be in the range from {0} to {1}..
        /// </summary>
        internal static string XmlDictionaryStringIDRange {
            get {
                return ResourceManager.GetString("XmlDictionaryStringIDRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XmlDictionaryString ID {0} not defined in the XmlBinaryReaderSession..
        /// </summary>
        internal static string XmlDictionaryStringIDUndefinedSession {
            get {
                return ResourceManager.GetString("XmlDictionaryStringIDUndefinedSession", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XmlDictionaryString ID {0} not defined in the static dictionary..
        /// </summary>
        internal static string XmlDictionaryStringIDUndefinedStatic {
            get {
                return ResourceManager.GetString("XmlDictionaryStringIDUndefinedStatic", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Duplicate attribute found. Both &apos;{0}&apos; and &apos;{1}&apos; are from the namespace &apos;{2}&apos;..
        /// </summary>
        internal static string XmlDuplicateAttribute {
            get {
                return ResourceManager.GetString("XmlDuplicateAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Only Element nodes have attributes..
        /// </summary>
        internal static string XmlElementAttributes {
            get {
                return ResourceManager.GetString("XmlElementAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The empty namespace requires a null or empty prefix..
        /// </summary>
        internal static string XmlEmptyNamespaceRequiresNullPrefix {
            get {
                return ResourceManager.GetString("XmlEmptyNamespaceRequiresNullPrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The encoding in the declaration &apos;{0}&apos; does not match the encoding of the document &apos;{1}&apos;..
        /// </summary>
        internal static string XmlEncodingMismatch {
            get {
                return ResourceManager.GetString("XmlEncodingMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XML encoding not supported..
        /// </summary>
        internal static string XmlEncodingNotSupported {
            get {
                return ResourceManager.GetString("XmlEncodingNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to End element &apos;{0}&apos; from namespace &apos;{1}&apos; expected. Found {2}..
        /// </summary>
        internal static string XmlEndElementExpected {
            get {
                return ResourceManager.GetString("XmlEndElementExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No corresponding start element is open..
        /// </summary>
        internal static string XmlEndElementNoOpenNodes {
            get {
                return ResourceManager.GetString("XmlEndElementNoOpenNodes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expected encoding &apos;{0}&apos; does not match the actual encoding &apos;{1}&apos;..
        /// </summary>
        internal static string XmlExpectedEncoding {
            get {
                return ResourceManager.GetString("XmlExpectedEncoding", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Element {0} from namespace {1} cannot have child contents to be deserialized as an object. Please use XElement to deserialize this pattern of XML..
        /// </summary>
        internal static string XmlForObjectCannotHaveContent {
            get {
                return ResourceManager.GetString("XmlForObjectCannotHaveContent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to cdata &apos;{0}&apos;.
        /// </summary>
        internal static string XmlFoundCData {
            get {
                return ResourceManager.GetString("XmlFoundCData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to comment &apos;{0}&apos;.
        /// </summary>
        internal static string XmlFoundComment {
            get {
                return ResourceManager.GetString("XmlFoundComment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to element &apos;{0}&apos; from namespace &apos;{1}&apos;.
        /// </summary>
        internal static string XmlFoundElement {
            get {
                return ResourceManager.GetString("XmlFoundElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to end element &apos;{0}&apos; from namespace &apos;{1}&apos;.
        /// </summary>
        internal static string XmlFoundEndElement {
            get {
                return ResourceManager.GetString("XmlFoundEndElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to end of file.
        /// </summary>
        internal static string XmlFoundEndOfFile {
            get {
                return ResourceManager.GetString("XmlFoundEndOfFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to node {0}.
        /// </summary>
        internal static string XmlFoundNodeType {
            get {
                return ResourceManager.GetString("XmlFoundNodeType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to text &apos;{0}&apos;.
        /// </summary>
        internal static string XmlFoundText {
            get {
                return ResourceManager.GetString("XmlFoundText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Non-empty start element expected. Found {0}..
        /// </summary>
        internal static string XmlFullStartElementExpected {
            get {
                return ResourceManager.GetString("XmlFullStartElementExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Non-empty start element &apos;{0}&apos; from namespace &apos;{1}&apos; expected. Found {2}..
        /// </summary>
        internal static string XmlFullStartElementLocalNameNsExpected {
            get {
                return ResourceManager.GetString("XmlFullStartElementLocalNameNsExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Non-empty start element &apos;{0}&apos; expected. Found {1}..
        /// </summary>
        internal static string XmlFullStartElementNameExpected {
            get {
                return ResourceManager.GetString("XmlFullStartElementNameExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ID already defined..
        /// </summary>
        internal static string XmlIDDefined {
            get {
                return ResourceManager.GetString("XmlIDDefined", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Text cannot be written outside the root element..
        /// </summary>
        internal static string XmlIllegalOutsideRoot {
            get {
                return ResourceManager.GetString("XmlIllegalOutsideRoot", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Base64 sequence length ({0}) not valid. Must be a multiple of 4..
        /// </summary>
        internal static string XmlInvalidBase64Length {
            get {
                return ResourceManager.GetString("XmlInvalidBase64Length", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The characters &apos;{0}&apos; at offset {1} are not a valid Base64 sequence..
        /// </summary>
        internal static string XmlInvalidBase64Sequence {
            get {
                return ResourceManager.GetString("XmlInvalidBase64Sequence", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to BinHex sequence length ({0}) not valid. Must be a multiple of 2..
        /// </summary>
        internal static string XmlInvalidBinHexLength {
            get {
                return ResourceManager.GetString("XmlInvalidBinHexLength", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The characters &apos;{0}&apos; at offset {1} are not a valid BinHex sequence..
        /// </summary>
        internal static string XmlInvalidBinHexSequence {
            get {
                return ResourceManager.GetString("XmlInvalidBinHexSequence", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid byte encoding..
        /// </summary>
        internal static string XmlInvalidBytes {
            get {
                return ResourceManager.GetString("XmlInvalidBytes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Character reference not valid..
        /// </summary>
        internal static string XmlInvalidCharRef {
            get {
                return ResourceManager.GetString("XmlInvalidCharRef", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XML comments cannot contain &apos;--&apos; or end with &apos;-&apos;..
        /// </summary>
        internal static string XmlInvalidCommentChars {
            get {
                return ResourceManager.GetString("XmlInvalidCommentChars", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value &apos;{0}&apos; cannot be parsed as the type &apos;{1}&apos;..
        /// </summary>
        internal static string XmlInvalidConversion {
            get {
                return ResourceManager.GetString("XmlInvalidConversion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value cannot be parsed as the type &apos;{0}&apos;..
        /// </summary>
        internal static string XmlInvalidConversionWithoutValue {
            get {
                return ResourceManager.GetString("XmlInvalidConversionWithoutValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XML declaration can only be written at the beginning of the document..
        /// </summary>
        internal static string XmlInvalidDeclaration {
            get {
                return ResourceManager.GetString("XmlInvalidDeclaration", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot call &apos;{0}&apos; while Depth is &apos;{1}&apos;..
        /// </summary>
        internal static string XmlInvalidDepth {
            get {
                return ResourceManager.GetString("XmlInvalidDepth", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XML encoding must be &apos;UTF-8&apos;..
        /// </summary>
        internal static string XmlInvalidEncoding_UTF8 {
            get {
                return ResourceManager.GetString("XmlInvalidEncoding_UTF8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Characters with hexadecimal values 0xFFFE and 0xFFFF are not valid..
        /// </summary>
        internal static string XmlInvalidFFFE {
            get {
                return ResourceManager.GetString("XmlInvalidFFFE", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The input source is not correctly formatted..
        /// </summary>
        internal static string XmlInvalidFormat {
            get {
                return ResourceManager.GetString("XmlInvalidFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to High surrogate char &apos;0x{0}&apos; not valid. High surrogate chars range from 0xD800 to 0xDBFF..
        /// </summary>
        internal static string XmlInvalidHighSurrogate {
            get {
                return ResourceManager.GetString("XmlInvalidHighSurrogate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ID must be &gt;.
        /// </summary>
        internal static string XmlInvalidID {
            get {
                return ResourceManager.GetString("XmlInvalidID", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Low surrogate char &apos;0x{0}&apos; not valid. Low surrogate chars range from 0xDC00 to 0xDFFF..
        /// </summary>
        internal static string XmlInvalidLowSurrogate {
            get {
                return ResourceManager.GetString("XmlInvalidLowSurrogate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The reader cannot be advanced..
        /// </summary>
        internal static string XmlInvalidOperation {
            get {
                return ResourceManager.GetString("XmlInvalidOperation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A prefix cannot be defined while WriteState is &apos;{0}&apos;..
        /// </summary>
        internal static string XmlInvalidPrefixState {
            get {
                return ResourceManager.GetString("XmlInvalidPrefixState", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expected XML qualified name. Found &apos;{0}&apos;..
        /// </summary>
        internal static string XmlInvalidQualifiedName {
            get {
                return ResourceManager.GetString("XmlInvalidQualifiedName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The data at the root level is invalid..
        /// </summary>
        internal static string XmlInvalidRootData {
            get {
                return ResourceManager.GetString("XmlInvalidRootData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;standalone&apos; value in declaration must be &apos;yes&apos; or &apos;no&apos;..
        /// </summary>
        internal static string XmlInvalidStandalone {
            get {
                return ResourceManager.GetString("XmlInvalidStandalone", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Stream returned by IStreamProvider cannot be null..
        /// </summary>
        internal static string XmlInvalidStream {
            get {
                return ResourceManager.GetString("XmlInvalidStream", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Surrogate char &apos;0x{0}&apos; not valid. Surrogate chars range from 0x10000 to 0x10FFFF..
        /// </summary>
        internal static string XmlInvalidSurrogate {
            get {
                return ResourceManager.GetString("XmlInvalidSurrogate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to UniqueId cannot be zero length..
        /// </summary>
        internal static string XmlInvalidUniqueId {
            get {
                return ResourceManager.GetString("XmlInvalidUniqueId", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; contains invalid UTF8 bytes..
        /// </summary>
        internal static string XmlInvalidUTF8Bytes {
            get {
                return ResourceManager.GetString("XmlInvalidUTF8Bytes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XML version must be &apos;1.0&apos;..
        /// </summary>
        internal static string XmlInvalidVersion {
            get {
                return ResourceManager.GetString("XmlInvalidVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; cannot be called while WriteState is &apos;{1}&apos;..
        /// </summary>
        internal static string XmlInvalidWriteState {
            get {
                return ResourceManager.GetString("XmlInvalidWriteState", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The byte 0x{0} is not valid at this location..
        /// </summary>
        internal static string XmlInvalidXmlByte {
            get {
                return ResourceManager.GetString("XmlInvalidXmlByte", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is not a valid xml:space value. Valid values are &apos;default&apos; and &apos;preserve&apos;..
        /// </summary>
        internal static string XmlInvalidXmlSpace {
            get {
                return ResourceManager.GetString("XmlInvalidXmlSpace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified key already exists in the dictionary..
        /// </summary>
        internal static string XmlKeyAlreadyExists {
            get {
                return ResourceManager.GetString("XmlKeyAlreadyExists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Line {0}, position {1}..
        /// </summary>
        internal static string XmlLineInfo {
            get {
                return ResourceManager.GetString("XmlLineInfo", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Malformed XML declaration..
        /// </summary>
        internal static string XmlMalformedDecl {
            get {
                return ResourceManager.GetString("XmlMalformedDecl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum array length quota ({0}) has been exceeded while reading XML data. This quota may be increased by changing the MaxArrayLength property on the XmlDictionaryReaderQuotas object used when creating the XML reader..
        /// </summary>
        internal static string XmlMaxArrayLengthExceeded {
            get {
                return ResourceManager.GetString("XmlMaxArrayLengthExceeded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XmlMaxArrayLengthOrMaxItemsQuotaExceeded: {0}.
        /// </summary>
        internal static string XmlMaxArrayLengthOrMaxItemsQuotaExceeded {
            get {
                return ResourceManager.GetString("XmlMaxArrayLengthOrMaxItemsQuotaExceeded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;maximum bytes per Read operation&apos; quota ({0}) has been exceeded while reading XML data. Long element start tags (consisting of the element name, attribute names and attribute values) may trigger this quota. This quota may be increased by changing the MaxBytesPerRead property on the XmlDictionaryReaderQuotas object used when creating the XML reader..
        /// </summary>
        internal static string XmlMaxBytesPerReadExceeded {
            get {
                return ResourceManager.GetString("XmlMaxBytesPerReadExceeded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum read depth ({0}) has been exceeded because XML data being read has more levels of nesting than is allowed by the quota. This quota may be increased by changing the MaxDepth property on the XmlDictionaryReaderQuotas object used when creating the XML reader..
        /// </summary>
        internal static string XmlMaxDepthExceeded {
            get {
                return ResourceManager.GetString("XmlMaxDepthExceeded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum string content length quota ({0}) has been exceeded while reading XML data. This quota may be increased by changing the MaxStringContentLength property on the XmlDictionaryReaderQuotas object used when creating the XML reader..
        /// </summary>
        internal static string XmlMaxStringContentLengthExceeded {
            get {
                return ResourceManager.GetString("XmlMaxStringContentLengthExceeded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This XmlWriter implementation does not support the &apos;{0}&apos; method..
        /// </summary>
        internal static string XmlMethodNotSupported {
            get {
                return ResourceManager.GetString("XmlMethodNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The surrogate pair is invalid. Missing a low surrogate character..
        /// </summary>
        internal static string XmlMissingLowSurrogate {
            get {
                return ResourceManager.GetString("XmlMissingLowSurrogate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are multiple root elements..
        /// </summary>
        internal static string XmlMultipleRootElements {
            get {
                return ResourceManager.GetString("XmlMultipleRootElements", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The namespace &apos;{0}&apos; is not defined..
        /// </summary>
        internal static string XmlNamespaceNotFound {
            get {
                return ResourceManager.GetString("XmlNamespaceNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Nested arrays are not supported..
        /// </summary>
        internal static string XmlNestedArraysNotSupported {
            get {
                return ResourceManager.GetString("XmlNestedArraysNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The document does not have a root element..
        /// </summary>
        internal static string XmlNoRootElement {
            get {
                return ResourceManager.GetString("XmlNoRootElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is an XML type and cannot be serialized when assigned to an interface type that does not implement IXmlSerializable (&apos;{1}&apos;.).
        /// </summary>
        internal static string XmlObjectAssignedToIncompatibleInterface {
            get {
                return ResourceManager.GetString("XmlObjectAssignedToIncompatibleInterface", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Only one root element is permitted per document..
        /// </summary>
        internal static string XmlOnlyOneRoot {
            get {
                return ResourceManager.GetString("XmlOnlyOneRoot", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Only a single typed value may be written inside an attribute or content..
        /// </summary>
        internal static string XmlOnlySingleValue {
            get {
                return ResourceManager.GetString("XmlOnlySingleValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Only whitespace characters can be written with this method..
        /// </summary>
        internal static string XmlOnlyWhitespace {
            get {
                return ResourceManager.GetString("XmlOnlyWhitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The prefix &apos;{0}&apos; is bound to the namespace &apos;{1}&apos; and cannot be changed to &apos;{2}&apos;..
        /// </summary>
        internal static string XmlPrefixBoundToNamespace {
            get {
                return ResourceManager.GetString("XmlPrefixBoundToNamespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Processing instructions (other than the XML declaration) and DTDs are not supported..
        /// </summary>
        internal static string XmlProcessingInstructionNotSupported {
            get {
                return ResourceManager.GetString("XmlProcessingInstructionNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefixes beginning with &apos;xml&apos; (regardless of casing) are reserved for use by XML..
        /// </summary>
        internal static string XmlReservedPrefix {
            get {
                return ResourceManager.GetString("XmlReservedPrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Whitespace must appear between attributes..
        /// </summary>
        internal static string XmlSpaceBetweenAttributes {
            get {
                return ResourceManager.GetString("XmlSpaceBetweenAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The namespace &apos;{1}&apos; can only be bound to the prefix &apos;{0}&apos;..
        /// </summary>
        internal static string XmlSpecificBindingNamespace {
            get {
                return ResourceManager.GetString("XmlSpecificBindingNamespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The prefix &apos;{0}&apos; can only be bound to the namespace &apos;{1}&apos;..
        /// </summary>
        internal static string XmlSpecificBindingPrefix {
            get {
                return ResourceManager.GetString("XmlSpecificBindingPrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Start element expected. Found {0}..
        /// </summary>
        internal static string XmlStartElementExpected {
            get {
                return ResourceManager.GetString("XmlStartElementExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Start element &apos;{0}&apos; from namespace &apos;{1}&apos; expected. Found {2}..
        /// </summary>
        internal static string XmlStartElementLocalNameNsExpected {
            get {
                return ResourceManager.GetString("XmlStartElementLocalNameNsExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Start element &apos;{0}&apos; expected. Found {1}..
        /// </summary>
        internal static string XmlStartElementNameExpected {
            get {
                return ResourceManager.GetString("XmlStartElementNameExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Start element &apos;{0}&apos; does not match end element &apos;{1}&apos;..
        /// </summary>
        internal static string XmlTagMismatch {
            get {
                return ResourceManager.GetString("XmlTagMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The token &apos;{0}&apos; was expected but found &apos;{1}&apos;..
        /// </summary>
        internal static string XmlTokenExpected {
            get {
                return ResourceManager.GetString("XmlTokenExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The prefix &apos;{0}&apos; is not defined..
        /// </summary>
        internal static string XmlUndefinedPrefix {
            get {
                return ResourceManager.GetString("XmlUndefinedPrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No matching start tag for end element..
        /// </summary>
        internal static string XmlUnexpectedEndElement {
            get {
                return ResourceManager.GetString("XmlUnexpectedEndElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected end of file. Following elements are not closed: {0}..
        /// </summary>
        internal static string XmlUnexpectedEndOfFile {
            get {
                return ResourceManager.GetString("XmlUnexpectedEndOfFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The XmlWriter is closed..
        /// </summary>
        internal static string XmlWriterClosed {
            get {
                return ResourceManager.GetString("XmlWriterClosed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to WriteState &apos;{0}&apos; not valid. Caller must write start element before serializing in contentOnly mode..
        /// </summary>
        internal static string XmlWriterMustBeInElement {
            get {
                return ResourceManager.GetString("XmlWriterMustBeInElement", resourceCulture);
            }
        }
    }
}