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

namespace Microsoft.Internal {
    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", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Strings {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Strings() {
        }
        
        /// <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("Microsoft.Internal.Strings", typeof(Strings).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 &apos;{0}&apos; is a reflection-only assembly which is not supported..
        /// </summary>
        internal static string Argument_AssemblyReflectionOnly {
            get {
                return ResourceManager.GetString("Argument_AssemblyReflectionOnly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; contains a reflection-only type which is not supported..
        /// </summary>
        internal static string Argument_ElementReflectionOnlyType {
            get {
                return ResourceManager.GetString("Argument_ElementReflectionOnlyType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;exports&apos; cannot be empty when ImportDefinition.ImportCardinality is ImportCardinality.ExactlyOne..
        /// </summary>
        internal static string Argument_ExportsEmpty {
            get {
                return ResourceManager.GetString("Argument_ExportsEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;exports&apos; cannot contain more than one element when ImportDefinition.ImportCardinality is ImportCardinality.ZeroOrOne or ImportCardinality.ExactlyOne..
        /// </summary>
        internal static string Argument_ExportsTooMany {
            get {
                return ResourceManager.GetString("Argument_ExportsTooMany", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; cannot contain a null (Nothing in Visual Basic) element..
        /// </summary>
        internal static string Argument_NullElement {
            get {
                return ResourceManager.GetString("Argument_NullElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; cannot be an empty string (&quot;&quot;)..
        /// </summary>
        internal static string ArgumentException_EmptyString {
            get {
                return ResourceManager.GetString("ArgumentException_EmptyString", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value of argument &apos;{0}&apos; ({1}) is invalid for Enum type &apos;{2}&apos;..
        /// </summary>
        internal static string ArgumentOutOfRange_InvalidEnum {
            get {
                return ResourceManager.GetString("ArgumentOutOfRange_InvalidEnum", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value of argument &apos;{0}&apos; ({1}) is not supported. Allowed values are : &apos;{2}&apos;..
        /// </summary>
        internal static string ArgumentOutOfRange_InvalidEnumInSet {
            get {
                return ResourceManager.GetString("ArgumentOutOfRange_InvalidEnumInSet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The argument was a value type which is not supported..
        /// </summary>
        internal static string ArgumentValueType {
            get {
                return ResourceManager.GetString("ArgumentValueType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assembly file {0} is either not found or not a dll or exe file..
        /// </summary>
        internal static string AssemblyFileNotFoundOrWrongType {
            get {
                return ResourceManager.GetString("AssemblyFileNotFoundOrWrongType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The atomicComposition can no longer be changed because the atomicComposition has already been completed..
        /// </summary>
        internal static string AtomicComposition_AlreadyCompleted {
            get {
                return ResourceManager.GetString("AtomicComposition_AlreadyCompleted", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The atomicComposition is already contains an inner atomicComposition and cannot contain more than one atomicComposition at a time..
        /// </summary>
        internal static string AtomicComposition_AlreadyNested {
            get {
                return ResourceManager.GetString("AtomicComposition_AlreadyNested", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The atomicComposition contains another inner atomicComposition and cannot be changed until the that inner atomicComposition has been completed..
        /// </summary>
        internal static string AtomicComposition_PartOfAnotherAtomicComposition {
            get {
                return ResourceManager.GetString("AtomicComposition_PartOfAnotherAtomicComposition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No valid exports were found that match the constraint &apos;{0}&apos;, invalid exports may have been rejected..
        /// </summary>
        internal static string CardinalityMismatch_NoExports {
            get {
                return ResourceManager.GetString("CardinalityMismatch_NoExports", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to More than one export was found that matches the constraint &apos;{0}&apos;..
        /// </summary>
        internal static string CardinalityMismatch_TooManyExports {
            get {
                return ResourceManager.GetString("CardinalityMismatch_TooManyExports", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unknown Origin.
        /// </summary>
        internal static string CompositionElement_UnknownOrigin {
            get {
                return ResourceManager.GetString("CompositionElement_UnknownOrigin", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The composition remains unchanged. The changes were rejected because of the following error(s): {0}.
        /// </summary>
        internal static string CompositionException_ChangesRejected {
            get {
                return ResourceManager.GetString("CompositionException_ChangesRejected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Element: {0}.
        /// </summary>
        internal static string CompositionException_ElementPrefix {
            get {
                return ResourceManager.GetString("CompositionException_ElementPrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Resulting in:.
        /// </summary>
        internal static string CompositionException_ErrorPrefix {
            get {
                return ResourceManager.GetString("CompositionException_ErrorPrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to create an instance of the Metadata view &apos;{0}&apos; because a constructor could not be selected.  Ensure that the type implements a constructor which takes an argument of type IDictionary&lt;string, object&gt;..
        /// </summary>
        internal static string CompositionException_MetadataViewInvalidConstructor {
            get {
                return ResourceManager.GetString("CompositionException_MetadataViewInvalidConstructor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The composition produced multiple composition errors, with {0:N0} root causes. The root causes are provided below..
        /// </summary>
        internal static string CompositionException_MultipleErrorsWithMultiplePaths {
            get {
                return ResourceManager.GetString("CompositionException_MultipleErrorsWithMultiplePaths", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to  {0} {1}.
        /// </summary>
        internal static string CompositionException_OriginFormat {
            get {
                return ResourceManager.GetString("CompositionException_OriginFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to --&gt; .
        /// </summary>
        internal static string CompositionException_OriginSeparator {
            get {
                return ResourceManager.GetString("CompositionException_OriginSeparator", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ).
        /// </summary>
        internal static string CompositionException_PathsCountSeparator {
            get {
                return ResourceManager.GetString("CompositionException_PathsCountSeparator", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Review the CompositionException.Errors property for more detailed information..
        /// </summary>
        internal static string CompositionException_ReviewErrorProperty {
            get {
                return ResourceManager.GetString("CompositionException_ReviewErrorProperty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The composition produced a single composition error, with {0:N0} root causes. The root causes are provided below..
        /// </summary>
        internal static string CompositionException_SingleErrorWithMultiplePaths {
            get {
                return ResourceManager.GetString("CompositionException_SingleErrorWithMultiplePaths", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The composition produced a single composition error. The root cause is provided below..
        /// </summary>
        internal static string CompositionException_SingleErrorWithSinglePath {
            get {
                return ResourceManager.GetString("CompositionException_SingleErrorWithSinglePath", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The catalog &apos;{0}&apos; could not load assembly &apos;{1}&apos;. {2}.
        /// </summary>
        internal static string CompositionTrace_Discovery_AssemblyLoadFailed {
            get {
                return ResourceManager.GetString("CompositionTrace_Discovery_AssemblyLoadFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ComposablePartDefinition &apos;{0}&apos; was ignored because it is an open generic type..
        /// </summary>
        internal static string CompositionTrace_Discovery_DefinitionContainsGenericParameters {
            get {
                return ResourceManager.GetString("CompositionTrace_Discovery_DefinitionContainsGenericParameters", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ComposablePartDefinition &apos;{0}&apos; was ignored because it contains no exports..
        /// </summary>
        internal static string CompositionTrace_Discovery_DefinitionContainsNoExports {
            get {
                return ResourceManager.GetString("CompositionTrace_Discovery_DefinitionContainsNoExports", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ComposablePartDefinition &apos;{0}&apos; was ignored because it was marked with PartNotDiscoverableAttribute..
        /// </summary>
        internal static string CompositionTrace_Discovery_DefinitionMarkedWithPartNotDiscoverableAttribute {
            get {
                return ResourceManager.GetString("CompositionTrace_Discovery_DefinitionMarkedWithPartNotDiscoverableAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The member or parameter &apos;{0}&apos; is marked with multiple Import and ImportMany attributes. Only the first attribute encountered will be respected..
        /// </summary>
        internal static string CompositionTrace_Discovery_MemberMarkedWithMultipleImportAndImportMany {
            get {
                return ResourceManager.GetString("CompositionTrace_Discovery_MemberMarkedWithMultipleImportAndImportMany", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ComposablePartDefinition &apos;{0}&apos; has been rejected. {1}.
        /// </summary>
        internal static string CompositionTrace_Rejection_DefinitionRejected {
            get {
                return ResourceManager.GetString("CompositionTrace_Rejection_DefinitionRejected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ComposablePartDefinition &apos;{0}&apos; that was previously rejected has been resurrected..
        /// </summary>
        internal static string CompositionTrace_Rejection_DefinitionResurrected {
            get {
                return ResourceManager.GetString("CompositionTrace_Rejection_DefinitionResurrected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot cast the underlying exported value of type &apos;{0}&apos; to type &apos;{1}&apos;..
        /// </summary>
        internal static string ContractMismatch_ExportedValueCannotBeCastToT {
            get {
                return ResourceManager.GetString("ContractMismatch_ExportedValueCannotBeCastToT", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to create an Instance of the Metadata view &apos;{0}&apos; because the exporter exported the metadata  for the item &apos;{1}&apos; with the value &apos;{2}&apos; as type &apos;{3}&apos; but the view imports it as type &apos;{4}&apos;..
        /// </summary>
        internal static string ContractMismatch_InvalidCastOnMetadataField {
            get {
                return ResourceManager.GetString("ContractMismatch_InvalidCastOnMetadataField", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to create an Instance of the Metadata view &apos;{0}&apos; because the exporter exported the metadata for the item &apos;{1}&apos; with a null value and null is not a valid value for type &apos;{2}&apos;..
        /// </summary>
        internal static string ContractMismatch_NullReferenceOnMetadataField {
            get {
                return ResourceManager.GetString("ContractMismatch_NullReferenceOnMetadataField", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Directory &apos;{0}&apos; could not be found..
        /// </summary>
        internal static string DirectoryNotFound {
            get {
                return ResourceManager.GetString("DirectoryNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member or Type &apos;{0}&apos; contains multiple metadata entries with the name &apos;{1}&apos;. The metadata entries could be coming from the ExportMetadataAttribute or from a property of a custom metadata attribute. Either remove the duplicate entries or enable the metadata entry with name &apos;{1}&apos; to allow multiple entries via the IsMultiple property on ExportMetadataAttribute or AttributeUsage.AllowMultiple on custom metadata attributes..
        /// </summary>
        internal static string Discovery_DuplicateMetadataNameValues {
            get {
                return ResourceManager.GetString("Discovery_DuplicateMetadataNameValues", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property &apos;{0}&apos; has type &apos;{1}&apos; which is an invalid metadata type. Metadata can only contain values with a type that is available to be embedded at compile-time into attributes. For more details of what types are valid reference section 17.1.3 in the C# specification..
        /// </summary>
        internal static string Discovery_MetadataContainsValueWithInvalidType {
            get {
                return ResourceManager.GetString("Discovery_MetadataContainsValueWithInvalidType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Member or Type &apos;{0}&apos; contains a metadata entry with the name &apos;{1}&apos;, which is a reserved metadata key name. Either remove this metadata entry or change the name associated with the entry..
        /// </summary>
        internal static string Discovery_ReservedMetadataNameUsed {
            get {
                return ResourceManager.GetString("Discovery_ReservedMetadataNameUsed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} did not originate from the ExportDefinitions property on this ComposablePart or its ComposablePartDefinition..
        /// </summary>
        internal static string ExportDefinitionNotOnThisComposablePart {
            get {
                return ResourceManager.GetString("ExportDefinitionNotOnThisComposablePart", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} did not originate from the ImportDefinitions property on this ComposablePart or its ComposablePartDefinition..
        /// </summary>
        internal static string ImportDefinitionNotOnThisComposablePart {
            get {
                return ResourceManager.GetString("ImportDefinitionNotOnThisComposablePart", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The composition failed because it did not complete within &apos;{0:N0}&apos; iterations. This is most likely caused by a cycle in the dependency graph of a part which is marked with a non-shared creation policy..
        /// </summary>
        internal static string ImportEngine_ComposeTookTooManyIterations {
            get {
                return ResourceManager.GetString("ImportEngine_ComposeTookTooManyIterations", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ComposablePart of type &apos;{0}&apos; cannot be recomposed because it is in an invalid state. It can only be recomposed if it has already been fully previewed or composed..
        /// </summary>
        internal static string ImportEngine_InvalidStateForRecomposition {
            get {
                return ResourceManager.GetString("ImportEngine_InvalidStateForRecomposition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot activate part &apos;{0}&apos;..
        /// </summary>
        internal static string ImportEngine_PartCannotActivate {
            get {
                return ResourceManager.GetString("ImportEngine_PartCannotActivate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot get export &apos;{0}&apos; from part &apos;{1}&apos;..
        /// </summary>
        internal static string ImportEngine_PartCannotGetExportedValue {
            get {
                return ResourceManager.GetString("ImportEngine_PartCannotGetExportedValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot set import &apos;{0}&apos; on part &apos;{1}&apos;..
        /// </summary>
        internal static string ImportEngine_PartCannotSetImport {
            get {
                return ResourceManager.GetString("ImportEngine_PartCannotSetImport", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot compose part &apos;{0}&apos; because a cycle exists in the dependencies between the exports being composed. To break this cycle, consider changing some imports from constructor to property injection..
        /// </summary>
        internal static string ImportEngine_PartCycle {
            get {
                return ResourceManager.GetString("ImportEngine_PartCycle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Change in exports prevented by non-recomposable import &apos;{0}&apos; on part &apos;{1}&apos;..
        /// </summary>
        internal static string ImportEngine_PreventedByExistingImport {
            get {
                return ResourceManager.GetString("ImportEngine_PreventedByExistingImport", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not finishing composing object of type &apos;{0}&apos;. The import &apos;{1}&apos; was not satisfied..
        /// </summary>
        internal static string ImportNotSetOnPart {
            get {
                return ResourceManager.GetString("ImportNotSetOnPart", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Internal error occurred. Additional information: &apos;{0}&apos;..
        /// </summary>
        internal static string InternalExceptionMessage {
            get {
                return ResourceManager.GetString("InternalExceptionMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Metadata can only contain values with a type that is available to be embedded at compile-time into attributes. For more details of what types are valid reference section 17.1.3 in the C# specification..
        /// </summary>
        internal static string InvalidMetadataValue {
            get {
                return ResourceManager.GetString("InvalidMetadataValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Type &apos;{0}&apos; supplied is not a valid Metadata View..
        /// </summary>
        internal static string InvalidMetadataView {
            get {
                return ResourceManager.GetString("InvalidMetadataView", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;definition&apos; cannot be set after Activate has been called because ImportDefinition.IsRecomposable is false..
        /// </summary>
        internal static string InvalidOperation_DefinitionCannotBeRecomposed {
            get {
                return ResourceManager.GetString("InvalidOperation_DefinitionCannotBeRecomposed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to GetExportedValue cannot be called before prerequisite import &apos;{0}&apos; has been set..
        /// </summary>
        internal static string InvalidOperation_GetExportedValueBeforePrereqImportSet {
            get {
                return ResourceManager.GetString("InvalidOperation_GetExportedValueBeforePrereqImportSet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A call to Compose occurred during a call to Compose on the same CompositionContainer object. Use the IsComposing property on CompositionContainer to ensure a composition is not already in progress before calling Compose..
        /// </summary>
        internal static string InvalidOperationReentrantCompose {
            get {
                return ResourceManager.GetString("InvalidOperationReentrantCompose", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The MetadataView &apos;{0}&apos; is invalid because property &apos;{1}&apos; has a property set method..
        /// </summary>
        internal static string InvalidSetterOnMetadataField {
            get {
                return ResourceManager.GetString("InvalidSetterOnMetadataField", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Accessors must not be null (Nothing in Visual Basic)..
        /// </summary>
        internal static string LazyMemberInfo_AccessorsNull {
            get {
                return ResourceManager.GetString("LazyMemberInfo_AccessorsNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A member of type &apos;{0}&apos; must have exactly a single accessor of type &apos;{0}&apos;.
        /// </summary>
        internal static string LazyMemberInfo_InvalidAccessorOnSimpleMember {
            get {
                return ResourceManager.GetString("LazyMemberInfo_InvalidAccessorOnSimpleMember", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All event accessors must be methods..
        /// </summary>
        internal static string LazyMemberinfo_InvalidEventAccessors_AccessorType {
            get {
                return ResourceManager.GetString("LazyMemberinfo_InvalidEventAccessors_AccessorType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An event must have exactly three accessors..
        /// </summary>
        internal static string LazyMemberInfo_InvalidEventAccessors_Cardinality {
            get {
                return ResourceManager.GetString("LazyMemberInfo_InvalidEventAccessors_Cardinality", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All property accessors must be methods..
        /// </summary>
        internal static string LazyMemberinfo_InvalidPropertyAccessors_AccessorType {
            get {
                return ResourceManager.GetString("LazyMemberinfo_InvalidPropertyAccessors_AccessorType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A property must have exactly two accessors..
        /// </summary>
        internal static string LazyMemberInfo_InvalidPropertyAccessors_Cardinality {
            get {
                return ResourceManager.GetString("LazyMemberInfo_InvalidPropertyAccessors_Cardinality", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A member must have at least one accessor..
        /// </summary>
        internal static string LazyMemberInfo_NoAccessors {
            get {
                return ResourceManager.GetString("LazyMemberInfo_NoAccessors", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The lazily evaluated value of type &apos;{0}&apos; passed to the ReflectionModelServices API as part of the argument &apos;{1}&apos; must not return null (Nothing in Visual Basic)..
        /// </summary>
        internal static string LazyServices_LazyResolvesToNull {
            get {
                return ResourceManager.GetString("LazyServices_LazyResolvesToNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This export does not support the metadata item &apos;{0}&apos;..
        /// </summary>
        internal static string MetadataItemNotSupported {
            get {
                return ResourceManager.GetString("MetadataItemNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} member must be overridden by a derived class..
        /// </summary>
        internal static string NotImplemented_NotOverriddenByDerived {
            get {
                return ResourceManager.GetString("NotImplemented_NotOverriddenByDerived", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Interface &apos;{0}&apos; is not a valid MetadataView; MetadataViews do not support non-public interfaces, and interfaces that contain members that are not properties..
        /// </summary>
        internal static string NotSupportedInterfaceMetadataView {
            get {
                return ResourceManager.GetString("NotSupportedInterfaceMetadataView", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The underlying dictionary is read-only..
        /// </summary>
        internal static string NotSupportedReadOnlyDictionary {
            get {
                return ResourceManager.GetString("NotSupportedReadOnlyDictionary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This property cannot be set after the object&apos;s public surface has been accessed..
        /// </summary>
        internal static string ObjectAlreadyInitialized {
            get {
                return ResourceManager.GetString("ObjectAlreadyInitialized", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This object has not been initialized - the property &apos;{0}&apos; must be set..
        /// </summary>
        internal static string ObjectMustBeInitialized {
            get {
                return ResourceManager.GetString("ObjectMustBeInitialized", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Currently composing another batch in this ComposablePartExportProvider. Only one batch can be composed at a time..
        /// </summary>
        internal static string ReentrantCompose {
            get {
                return ResourceManager.GetString("ReentrantCompose", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot get the value of property &apos;{0}&apos;, because the member is not readable. The property must have an accessible getter..
        /// </summary>
        internal static string ReflectionModel_ExportNotReadable {
            get {
                return ResourceManager.GetString("ReflectionModel_ExportNotReadable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An exception occurred while trying to get the value of property &apos;{0}&apos;..
        /// </summary>
        internal static string ReflectionModel_ExportThrewException {
            get {
                return ResourceManager.GetString("ReflectionModel_ExportThrewException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot populate the collection &apos;{0}&apos; because an exception occurred while calling the Add method on the type &apos;{1}&apos;..
        /// </summary>
        internal static string ReflectionModel_ImportCollectionAddThrewException {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportCollectionAddThrewException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot populate the collection &apos;{0}&apos; because an exception occurred while calling the Clear method on the type &apos;{1}&apos;..
        /// </summary>
        internal static string ReflectionModel_ImportCollectionClearThrewException {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportCollectionClearThrewException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot populate the collection &apos;{0}&apos; because an exception occurred while calling the default constructor on the type &apos;{1}&apos;..
        /// </summary>
        internal static string ReflectionModel_ImportCollectionConstructionThrewException {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportCollectionConstructionThrewException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot populate the collection &apos;{0}&apos; because an exception occurred while trying to access the collection value. If the collection is not IEnumerable&lt;T&gt; or T[] it must implement ICollection&lt;T&gt; and be either pre-initialized or be writable with a default constructor..
        /// </summary>
        internal static string ReflectionModel_ImportCollectionGetThrewException {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportCollectionGetThrewException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot populate the collection &apos;{0}&apos; because an exception occurred while reading the IsReadOnly property on the type &apos;{1}&apos;..
        /// </summary>
        internal static string ReflectionModel_ImportCollectionIsReadOnlyThrewException {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportCollectionIsReadOnlyThrewException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot populate the collection &apos;{0}&apos; because it does not implement ICollection&lt;T&gt; or is read-only. If the collection is not IEnumerable&lt;T&gt; or T[] it must implement ICollection&lt;T&gt; and be either pre-initialized or be writable with a default constructor..
        /// </summary>
        internal static string ReflectionModel_ImportCollectionNotWritable {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportCollectionNotWritable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot populate the value of enumerable member &apos;{0}&apos; because it is null (Nothing in Visual Basic). If the collection is not IEnumerable&lt;T&gt; or T[] it must implement ICollection&lt;T&gt; and be either pre-initialized or be writable with a default constructor..
        /// </summary>
        internal static string ReflectionModel_ImportCollectionNull {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportCollectionNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The importing constructor on type &apos;{0}&apos; is using ImportManyAttribute on parameter &apos;{1}&apos; with a non-assignable type. On constructor parameters the ImportManyAttribute only supports importing into types T[] or IEnumerable&lt;T&gt;..
        /// </summary>
        internal static string ReflectionModel_ImportManyOnParameterCanOnlyBeAssigned {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportManyOnParameterCanOnlyBeAssigned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The export &apos;{0}&apos; is not assignable to type &apos;{1}&apos;..
        /// </summary>
        internal static string ReflectionModel_ImportNotAssignableFromExport {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportNotAssignableFromExport", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot set the value of &apos;{0}&apos; because the member is not writable. If the member is a property, it must have an accessible setter; otherwise, if it is a field, it must not be read-only..
        /// </summary>
        internal static string ReflectionModel_ImportNotWritable {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportNotWritable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An exception occurred while trying to set the value of property &apos;{0}&apos;..
        /// </summary>
        internal static string ReflectionModel_ImportThrewException {
            get {
                return ResourceManager.GetString("ReflectionModel_ImportThrewException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ExportDefinition of type &apos;{0}&apos; cannot be used in this context. Only export definitions produced by the ReflectionModelServices.CreateExportDefinition are supported..
        /// </summary>
        internal static string ReflectionModel_InvalidExportDefinition {
            get {
                return ResourceManager.GetString("ReflectionModel_InvalidExportDefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ImportDefinition of type &apos;{0}&apos; cannot be used in this context. Only import definitions produced by the ReflectionModelServices.CreateImportDefinition are supported..
        /// </summary>
        internal static string ReflectionModel_InvalidImportDefinition {
            get {
                return ResourceManager.GetString("ReflectionModel_InvalidImportDefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ImportDefinition of type &apos;{0}&apos; cannot be used in this context. Only import definitions produced by the ReflectionModelServices.CreateImportDefinition based on members are supported. Use ReflectionModelServices.IsImportingParameter to determine whether a given import definition is based on a member or a parameter..
        /// </summary>
        internal static string ReflectionModel_InvalidMemberImportDefinition {
            get {
                return ResourceManager.GetString("ReflectionModel_InvalidMemberImportDefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ImportDefinition of type &apos;{0}&apos; cannot be used in this context. Only import definitions produced by the ReflectionModelServices.CreateImportDefinition based on parameters are supported. Use ReflectionModelServices.IsImportingParameter to determine whether a given import definition is based on a member or a parameter..
        /// </summary>
        internal static string ReflectionModel_InvalidParameterImportDefinition {
            get {
                return ResourceManager.GetString("ReflectionModel_InvalidParameterImportDefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ComposablePartDefinition of type &apos;{0}&apos; cannot be used in this context. Only part definitions produced by the ReflectionModelServices.CreatePartDefinition are supported..
        /// </summary>
        internal static string ReflectionModel_InvalidPartDefinition {
            get {
                return ResourceManager.GetString("ReflectionModel_InvalidPartDefinition", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot create an instance of type &apos;{0}&apos; because a constructor could not be selected for construction. Ensure that the type either has a default constructor, or a single constructor marked with the &apos;System.ComponentModel.Composition.ImportingConstructorAttribute&apos;..
        /// </summary>
        internal static string ReflectionModel_PartConstructorMissing {
            get {
                return ResourceManager.GetString("ReflectionModel_PartConstructorMissing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An exception occurred while trying to create an instance of type &apos;{0}&apos;..
        /// </summary>
        internal static string ReflectionModel_PartConstructorThrewException {
            get {
                return ResourceManager.GetString("ReflectionModel_PartConstructorThrewException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An exception occurred while calling the &apos;OnImportsSatisfied&apos; method on type &apos;{0}&apos;..
        /// </summary>
        internal static string ReflectionModel_PartOnImportsSatisfiedThrewException {
            get {
                return ResourceManager.GetString("ReflectionModel_PartOnImportsSatisfiedThrewException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} (Types=&apos;{1}&apos;)..
        /// </summary>
        internal static string TypeCatalog_DisplayNameFormat {
            get {
                return ResourceManager.GetString("TypeCatalog_DisplayNameFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;Empty&gt;.
        /// </summary>
        internal static string TypeCatalog_Empty {
            get {
                return ResourceManager.GetString("TypeCatalog_Empty", resourceCulture);
            }
        }
    }
}