path: root/src/DotNetOpenId/Strings.Designer.cs

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

namespace DotNetOpenId {
    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", "2.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("DotNetOpenId.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 An attribute with type URI &apos;{0}&apos; has already been added..
        /// </summary>
        internal static string AttributeAlreadyAdded {
            get {
                return ResourceManager.GetString("AttributeAlreadyAdded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Only {0} values for attribute &apos;{1}&apos; were requested, but {2} were supplied..
        /// </summary>
        internal static string AttributeTooManyValues {
            get {
                return ResourceManager.GetString("AttributeTooManyValues", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The private data supplied does not meet the requirements of any known Association type.  Its length may be too short, or it may have been corrupted..
        /// </summary>
        internal static string BadAssociationPrivateData {
            get {
                return ResourceManager.GetString("BadAssociationPrivateData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A Simple Registration request must be deserialized before CreateResponse can be called..
        /// </summary>
        internal static string CallDeserializeBeforeCreateResponse {
            get {
                return ResourceManager.GetString("CallDeserializeBeforeCreateResponse", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XRI CanonicalID verification failed..
        /// </summary>
        internal static string CIDVerificationFailed {
            get {
                return ResourceManager.GetString("CIDVerificationFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ClaimedIdentifier property cannot be set when IsDelegatedIdentifier is true to avoid breaking OpenID URL delegation..
        /// </summary>
        internal static string ClaimedIdentifierCannotBeSetOnDelegatedAuthentication {
            get {
                return ResourceManager.GetString("ClaimedIdentifierCannotBeSetOnDelegatedAuthentication", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ClaimedIdentifier property must be set first..
        /// </summary>
        internal static string ClaimedIdentifierMustBeSetFirst {
            get {
                return ResourceManager.GetString("ClaimedIdentifierMustBeSetFirst", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An extension with this property name (&apos;{0}&apos;) has already been registered..
        /// </summary>
        internal static string ClientScriptExtensionPropertyNameCollision {
            get {
                return ResourceManager.GetString("ClientScriptExtensionPropertyNameCollision", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The extension &apos;{0}&apos; has already been registered..
        /// </summary>
        internal static string ClientScriptExtensionTypeCollision {
            get {
                return ResourceManager.GetString("ClientScriptExtensionTypeCollision", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An authentication request has already been created using CreateRequest()..
        /// </summary>
        internal static string CreateRequestAlreadyCalled {
            get {
                return ResourceManager.GetString("CreateRequestAlreadyCalled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HttpContext.Current is null.  There must be an ASP.NET request in process for this operation to succeed..
        /// </summary>
        internal static string CurrentHttpContextRequired {
            get {
                return ResourceManager.GetString("CurrentHttpContextRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An encrypted session using either HTTPS or Diffie-Hellman is required when establishing associations between relying parties and providers..
        /// </summary>
        internal static string EncryptionRequired {
            get {
                return ResourceManager.GetString("EncryptionRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OpenID parameter &apos;{0}&apos; was expected to be base64 encoded but is not..
        /// </summary>
        internal static string ExpectedBase64OpenIdQueryParameter {
            get {
                return ResourceManager.GetString("ExpectedBase64OpenIdQueryParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The nonce has expired.  It was good until {0} (UTC), and it is now {1} (UTC).  If this looks wrong, check the server&apos;s clock, time zone and daylight savings settings..
        /// </summary>
        internal static string ExpiredNonce {
            get {
                return ResourceManager.GetString("ExpiredNonce", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to URI is not SSL yet requireSslDiscovery is set to true..
        /// </summary>
        internal static string ExplicitHttpUriSuppliedWithSslRequirement {
            get {
                return ResourceManager.GetString("ExplicitHttpUriSuppliedWithSslRequirement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An extension sharing namespace &apos;{0}&apos; has already been added.  Only one extension per namespace is allowed in a given request..
        /// </summary>
        internal static string ExtensionAlreadyAddedWithSameTypeURI {
            get {
                return ResourceManager.GetString("ExtensionAlreadyAddedWithSameTypeURI", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Extension parameter key &apos;{0}&apos; encountered, but extension parameter keys should not include their prefix..
        /// </summary>
        internal static string ExtensionParameterKeysWithoutPrefixExpected {
            get {
                return ResourceManager.GetString("ExtensionParameterKeysWithoutPrefixExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The OpenID parameter &apos;{0}&apos; must be signed by the OpenID Provider, but was not..
        /// </summary>
        internal static string FieldMustBeSigned {
            get {
                return ResourceManager.GetString("FieldMustBeSigned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fragment segments do not apply to XRI identifiers..
        /// </summary>
        internal static string FragmentNotAllowedOnXRIs {
            get {
                return ResourceManager.GetString("FragmentNotAllowedOnXRIs", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No current ASP.NET HttpContext was detected.  Use an overload that does not require one..
        /// </summary>
        internal static string HttpContextRequiredForThisOverload {
            get {
                return ResourceManager.GetString("HttpContextRequiredForThisOverload", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No current HttpContext was detected, so an IAssociationStore must be explicitly provided. Call the Server constructor overload that takes an IAssociationStore..
        /// </summary>
        internal static string IAssociationStoreRequiredWhenNoHttpContextAvailable {
            get {
                return ResourceManager.GetString("IAssociationStoreRequiredWhenNoHttpContextAvailable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ClaimedIdentifier and LocalIdentifier must be the same when IsIdentifierSelect is true..
        /// </summary>
        internal static string IdentifierSelectRequiresMatchingIdentifiers {
            get {
                return ResourceManager.GetString("IdentifierSelectRequiresMatchingIdentifiers", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Provider requested association type &apos;{0}&apos; and session type &apos;{1}&apos;, which are not compatible with each other..
        /// </summary>
        internal static string IncompatibleAssociationAndSessionTypes {
            get {
                return ResourceManager.GetString("IncompatibleAssociationAndSessionTypes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Inconsistent setting of application state.  Authentication request was sent with application state available, but authentication response was received without it available.  This makes it impossible to validate the token&apos;s signature and will cause assertion verification failure..
        /// </summary>
        internal static string InconsistentAppState {
            get {
                return ResourceManager.GetString("InconsistentAppState", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Insecure web request for &apos;{0}&apos; aborted due to security requirements demanding HTTPS..
        /// </summary>
        internal static string InsecureWebRequestWithSslRequired {
            get {
                return ResourceManager.GetString("InsecureWebRequestWithSslRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot encode &apos;{0}&apos; because it contains an illegal character for Key-Value Form encoding.  (line {1}: &apos;{2}&apos;).
        /// </summary>
        internal static string InvalidCharacterInKeyValueFormInput {
            get {
                return ResourceManager.GetString("InvalidCharacterInKeyValueFormInput", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot decode Key-Value Form because a line was found without a &apos;{0}&apos; character.  (line {1}: &apos;{2}&apos;).
        /// </summary>
        internal static string InvalidKeyValueFormCharacterMissing {
            get {
                return ResourceManager.GetString("InvalidKeyValueFormCharacterMissing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The nonce was not in the expected format..
        /// </summary>
        internal static string InvalidNonce {
            get {
                return ResourceManager.GetString("InvalidNonce", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OpenID extension {0} parameter {1} had unexpected value &apos;{2}&apos;..
        /// </summary>
        internal static string InvalidOpenIdExtensionParameterValue {
            get {
                return ResourceManager.GetString("InvalidOpenIdExtensionParameterValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OpenID parameter &apos;{0}&apos; had unexpected value &apos;{1}&apos;..
        /// </summary>
        internal static string InvalidOpenIdQueryParameterValue {
            get {
                return ResourceManager.GetString("InvalidOpenIdQueryParameterValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OpenID parameter &apos;{0}&apos; with value &apos;{1}&apos; failed to base64 decode..
        /// </summary>
        internal static string InvalidOpenIdQueryParameterValueBadBase64 {
            get {
                return ResourceManager.GetString("InvalidOpenIdQueryParameterValueBadBase64", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The scheme must be http or https but was &apos;{0}&apos;..
        /// </summary>
        internal static string InvalidScheme {
            get {
                return ResourceManager.GetString("InvalidScheme", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signature verification failed..
        /// </summary>
        internal static string InvalidSignature {
            get {
                return ResourceManager.GetString("InvalidSignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value &apos;{0}&apos; is not a valid URI..
        /// </summary>
        internal static string InvalidUri {
            get {
                return ResourceManager.GetString("InvalidUri", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Failure parsing XRDS document..
        /// </summary>
        internal static string InvalidXRDSDocument {
            get {
                return ResourceManager.GetString("InvalidXRDSDocument", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Not a recognized XRI format: &apos;{0}&apos;..
        /// </summary>
        internal static string InvalidXri {
            get {
                return ResourceManager.GetString("InvalidXri", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The OpenId Provider issued an assertion for an Identifier whose discovery information did not match.  
        ///Assertion endpoint info: 
        ///{0}
        ///Discovered endpoint info:
        ///{1}.
        /// </summary>
        internal static string IssuedAssertionFailsIdentifierDiscovery {
            get {
                return ResourceManager.GetString("IssuedAssertionFailsIdentifierDiscovery", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The given key &apos;{0}&apos; already exists..
        /// </summary>
        internal static string KeyAlreadyExists {
            get {
                return ResourceManager.GetString("KeyAlreadyExists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The list of keys do not match the provided dictionary..
        /// </summary>
        internal static string KeysListAndDictionaryDoNotMatch {
            get {
                return ResourceManager.GetString("KeysListAndDictionaryDoNotMatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; and &apos;{1}&apos; parameters must both be or not be &apos;{2}&apos;..
        /// </summary>
        internal static string MatchingArgumentsExpected {
            get {
                return ResourceManager.GetString("MatchingArgumentsExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This Relying Party requires a Provider that supports at least OpenID version {0}, but Provider is detected to only support OpenID version {1}..
        /// </summary>
        internal static string MinimumOPVersionRequirementNotMet {
            get {
                return ResourceManager.GetString("MinimumOPVersionRequirementNotMet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The XRDS document for XRI {0} is missing the required CanonicalID element..
        /// </summary>
        internal static string MissingCanonicalIDElement {
            get {
                return ResourceManager.GetString("MissingCanonicalIDElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Query parameter &apos;{0}&apos; was missing from the query..
        /// </summary>
        internal static string MissingInternalQueryParameter {
            get {
                return ResourceManager.GetString("MissingInternalQueryParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OpenID parameter &apos;{0}&apos; was missing from the query..
        /// </summary>
        internal static string MissingOpenIdQueryParameter {
            get {
                return ResourceManager.GetString("MissingOpenIdQueryParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Query parameter &apos;{0}&apos; was expected in the return_to query &apos;{1}&apos;..
        /// </summary>
        internal static string MissingReturnToQueryParameter {
            get {
                return ResourceManager.GetString("MissingReturnToQueryParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No XRDS document containing OpenId relying party endpoint information could be found at {0}..
        /// </summary>
        internal static string NoRelyingPartyEndpointDiscovered {
            get {
                return ResourceManager.GetString("NoRelyingPartyEndpointDiscovered", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This operation is not supported by serialized authentication responses.  Try this operation from the LoggedIn event handler..
        /// </summary>
        internal static string NotSupportedByAuthenticationSnapshot {
            get {
                return ResourceManager.GetString("NotSupportedByAuthenticationSnapshot", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Positive assertion sent with OpenID version {0} but Identifier discovery suggested it would be {1}..
        /// </summary>
        internal static string OpenIdDiscoveredAndActualVersionMismatch {
            get {
                return ResourceManager.GetString("OpenIdDiscoveredAndActualVersionMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No OpenId endpoint found..
        /// </summary>
        internal static string OpenIdEndpointNotFound {
            get {
                return ResourceManager.GetString("OpenIdEndpointNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No OpenId url is provided..
        /// </summary>
        internal static string OpenIdTextBoxEmpty {
            get {
                return ResourceManager.GetString("OpenIdTextBoxEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This operation is only allowed when IAuthenticationResponse.State == AuthenticationStatus.SetupRequired..
        /// </summary>
        internal static string OperationOnlyValidForSetupRequiredState {
            get {
                return ResourceManager.GetString("OperationOnlyValidForSetupRequiredState", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prefix should not begin or end with a period..
        /// </summary>
        internal static string PrefixWithoutPeriodsExpected {
            get {
                return ResourceManager.GetString("PrefixWithoutPeriodsExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to determine provider&apos;s OpenID version..
        /// </summary>
        internal static string ProviderOpenIdVersionUnknown {
            get {
                return ResourceManager.GetString("ProviderOpenIdVersionUnknown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The OpenId Provider responded with an error: &apos;{0}&apos;..
        /// </summary>
        internal static string ProviderRespondedWithError {
            get {
                return ResourceManager.GetString("ProviderRespondedWithError", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The OpenId Provider responded with unrecognized HTTP status code {0}..
        /// </summary>
        internal static string ProviderRespondedWithUnrecognizedHTTPStatusCode {
            get {
                return ResourceManager.GetString("ProviderRespondedWithUnrecognizedHTTPStatusCode", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An HTTP request to the realm URL ({0}) resulted in a redirect, which is not allowed during relying party discovery..
        /// </summary>
        internal static string RealmCausedRedirectUponDiscovery {
            get {
                return ResourceManager.GetString("RealmCausedRedirectUponDiscovery", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The nonce has already been used..
        /// </summary>
        internal static string ReplayAttackDetected {
            get {
                return ResourceManager.GetString("ReplayAttackDetected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OpenId provider&apos;s response is not ready.  Use IsResponseReady to check, and fill in the required properties first..
        /// </summary>
        internal static string ResponseNotReady {
            get {
                return ResourceManager.GetString("ResponseNotReady", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; parameter does not have the same value for return_to (&apos;{1}&apos;) and the regular query (&apos;{2}&apos;)..
        /// </summary>
        internal static string ReturnToArgDifferentFromQueryArg {
            get {
                return ResourceManager.GetString("ReturnToArgDifferentFromQueryArg", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to return_to &apos;{0}&apos; not under realm &apos;{1}&apos;..
        /// </summary>
        internal static string ReturnToNotUnderRealm {
            get {
                return ResourceManager.GetString("ReturnToNotUnderRealm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} parameter ({1}) does not match the actual URL ({2}) the request was made with..
        /// </summary>
        internal static string ReturnToParamDoesNotMatchRequestUrl {
            get {
                return ResourceManager.GetString("ReturnToParamDoesNotMatchRequestUrl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid birthdate value.  Must be in the form yyyy-MM-dd..
        /// </summary>
        internal static string SregInvalidBirthdate {
            get {
                return ResourceManager.GetString("SregInvalidBirthdate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; parameter was expected to have the value &apos;{1}&apos; but had &apos;{2}&apos; instead..
        /// </summary>
        internal static string TamperingDetected {
            get {
                return ResourceManager.GetString("TamperingDetected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum allowable number of redirects were exceeded while requesting &apos;{0}&apos;..
        /// </summary>
        internal static string TooManyRedirects {
            get {
                return ResourceManager.GetString("TooManyRedirects", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type must implement {0}..
        /// </summary>
        internal static string TypeMustImplementX {
            get {
                return ResourceManager.GetString("TypeMustImplementX", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The URL &apos;{0}&apos; is rated unsafe and cannot be requested this way..
        /// </summary>
        internal static string UnsafeWebRequestDetected {
            get {
                return ResourceManager.GetString("UnsafeWebRequestDetected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Providing a DateTime whose Kind is Unspecified is not allowed..
        /// </summary>
        internal static string UnspecifiedDateTimeKindNotAllowed {
            get {
                return ResourceManager.GetString("UnspecifiedDateTimeKindNotAllowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Web request to &apos;{0}&apos; failed..
        /// </summary>
        internal static string WebRequestFailed {
            get {
                return ResourceManager.GetString("WebRequestFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to XRI resolution failed..
        /// </summary>
        internal static string XriResolutionFailed {
            get {
                return ResourceManager.GetString("XriResolutionFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not find XRI resolution Status tag or code attribute was invalid..
        /// </summary>
        internal static string XriResolutionStatusMissing {
            get {
                return ResourceManager.GetString("XriResolutionStatusMissing", resourceCulture);
            }
        }
    }
}