PowerShell-PowerShell/scripts/string_resources/TabCompletionStrings.cs

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

using System;
using System.Reflection;



/// <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 TabCompletionStrings {
    
    private static global::System.Resources.ResourceManager resourceMan;
    
    private static global::System.Globalization.CultureInfo resourceCulture;
    
    [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
    internal TabCompletionStrings() {
    }
    
    /// <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("TabCompletionStrings", typeof(TabCompletionStrings).GetTypeInfo().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 Logical and. Returns TRUE when both statements are TRUE..
    /// </summary>
    internal static string andOperatorDescription {
        get {
            return ResourceManager.GetString("andOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Converts the left operand to the specified .NET Framework type (right operand)..
    /// </summary>
    internal static string asOperatorDescription {
        get {
            return ResourceManager.GetString("asOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Bitwise AND.
    /// </summary>
    internal static string bandOperatorDescription {
        get {
            return ResourceManager.GetString("bandOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Bitwise NOT.
    /// </summary>
    internal static string bnotOperatorDescription {
        get {
            return ResourceManager.GetString("bnotOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Bitwise OR (inclusive).
    /// </summary>
    internal static string borOperatorDescription {
        get {
            return ResourceManager.GetString("borOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Bitwise OR (exclusive).
    /// </summary>
    internal static string bxorOperatorDescription {
        get {
            return ResourceManager.GetString("bxorOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to The tab completion result cannot be properly deserialized because the remote runspace does not contain a TypeTable instance..
    /// </summary>
    internal static string CannotDeserializeTabCompletionResult {
        get {
            return ResourceManager.GetString("CannotDeserializeTabCompletionResult", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case sensitive. Returns TRUE only when the test value (right operand) exactly matches at least one of the values in the left operand..
    /// </summary>
    internal static string ccontainsOperatorDescription {
        get {
            return ResourceManager.GetString("ccontainsOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Equal to - case sensitive. When the left operand is a collection, returns values from the collection that equal the right operand, otherwise returns TRUE if the left operand equals the right operand..
    /// </summary>
    internal static string ceqOperatorDescription {
        get {
            return ResourceManager.GetString("ceqOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Greater than or equal to - case sensitive. When the left operand is a collection, returns values from the collection that are greater than or equal to the right operand, otherwise returns TRUE if the left operand is greater than or equal to the right operand..
    /// </summary>
    internal static string cgeOperatorDescription {
        get {
            return ResourceManager.GetString("cgeOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Greater than - case sensitive. When the left operand is a collection, returns values from the collection that are greater than the right operand, otherwise returns TRUE if the left operand is greater than the right operand..
    /// </summary>
    internal static string cgtOperatorDescription {
        get {
            return ResourceManager.GetString("cgtOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case sensitive. Returns TRUE when the test value (left operand) exactly matches at least one of the values in the right operand..
    /// </summary>
    internal static string cinOperatorDescription {
        get {
            return ResourceManager.GetString("cinOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Less than or equal to - case sensitive. When the left operand is a collection, returns values from the collection that are less than or equal to the right operand, otherwise returns TRUE if the left operand is less than or equal to the right operand..
    /// </summary>
    internal static string cleOperatorDescription {
        get {
            return ResourceManager.GetString("cleOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Wildcard matching operator - case sensitive. When the left operand is a collection, returns values from the collection that match the right hand operand, otherwise returns TRUE if the left operand matches the right operand..
    /// </summary>
    internal static string clikeOperatorDescription {
        get {
            return ResourceManager.GetString("clikeOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Less than - case sensitive. When the left operand is a collection, returns values from the collection that are less than the right operand, otherwise returns TRUE if the left operand is less than the right operand..
    /// </summary>
    internal static string cltOperatorDescription {
        get {
            return ResourceManager.GetString("cltOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Regular expression matching operator - case sensitive. When the left operand is a collection, returns values from the collection that match the right hand operand, otherwise returns TRUE if the left operand matches the right operand..
    /// </summary>
    internal static string cmatchOperatorDescription {
        get {
            return ResourceManager.GetString("cmatchOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Not equal to - case sensitive. When the left operand is a collection, returns values from the collection that do not equal the right operand, otherwise returns TRUE if the left operand does not equal the right operand..
    /// </summary>
    internal static string cneOperatorDescription {
        get {
            return ResourceManager.GetString("cneOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case sensitive. Returns TRUE when the test value (right operand) exactly matches none of the values in the left operand..
    /// </summary>
    internal static string cnotcontainsOperatorDescription {
        get {
            return ResourceManager.GetString("cnotcontainsOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case sensitive. Returns TRUE when the test value (left operand) exactly matches none of the values in the right operand..
    /// </summary>
    internal static string cnotinOperatorDescription {
        get {
            return ResourceManager.GetString("cnotinOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Wildcard matching operator - case sensitive. When the left operand is a collection, returns values from the collection that do not match the right hand operand, otherwise returns TRUE if the left operand does not match the right operand..
    /// </summary>
    internal static string cnotlikeOperatorDescription {
        get {
            return ResourceManager.GetString("cnotlikeOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Regular expression matching operator - case sensitive. When the left operand is a collection, returns values from the collection that do not match the right hand operand, otherwise returns TRUE if the left operand does not match the right operand..
    /// </summary>
    internal static string cnotmatchOperatorDescription {
        get {
            return ResourceManager.GetString("cnotmatchOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case insensitive. Returns TRUE when the test value (right operand) exactly matches at least one of the values in the left operand..
    /// </summary>
    internal static string containsOperatorDescription {
        get {
            return ResourceManager.GetString("containsOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Replace operator - case sensitive. Changes the left operand. Example: (dir *.ps1).FullName -replace &apos;.ps1$&apos;,&apos;.ps1.bak&apos;.
    /// </summary>
    internal static string creplaceOperatorDescription {
        get {
            return ResourceManager.GetString("creplaceOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Split - case sensitive. Split one or more strings into substrings.
    ///-Split &lt;String&gt;
    ///
    ///&lt;String&gt; -Split &lt;Delimiter&gt;[,&lt;Max-substrings&gt;[,&quot;&lt;Options&gt;&quot;]]
    ///
    ///&lt;String&gt; -Split {&lt;ScriptBlock&gt;} [,&lt;Max-substrings&gt;].
    /// </summary>
    internal static string csplitOperatorDescription {
        get {
            return ResourceManager.GetString("csplitOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Equal to - case insensitive. When the left operand is a collection, returns values from the collection that equal the right operand, otherwise returns TRUE if the left operand equals the right operand..
    /// </summary>
    internal static string eqOperatorDescription {
        get {
            return ResourceManager.GetString("eqOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Formats strings by using the format method of string objects..
    /// </summary>
    internal static string fOperatorDescription {
        get {
            return ResourceManager.GetString("fOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Greater than or equal to - case insensitive. When the left operand is a collection, returns values from the collection that are greater than or equal to the right operand, otherwise returns TRUE if the left operand is greater than or equal to the right operand..
    /// </summary>
    internal static string geOperatorDescription {
        get {
            return ResourceManager.GetString("geOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Greater than - case insensitive. When the left operand is a collection, returns values from the collection that are greater than the right operand, otherwise returns TRUE if the left operand is greater than the right operand..
    /// </summary>
    internal static string gtOperatorDescription {
        get {
            return ResourceManager.GetString("gtOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - incase sensitive. Returns TRUE when the test value (right operand) exactly matches at least one of the values in the left operand..
    /// </summary>
    internal static string icontainsOperatorDescription {
        get {
            return ResourceManager.GetString("icontainsOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Equal to - case insensitive. When the left operand is a collection, returns values from the collection that equal the right operand, otherwise returns TRUE if the left operand equals the right operand..
    /// </summary>
    internal static string ieqOperatorDescription {
        get {
            return ResourceManager.GetString("ieqOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Greater than or equal to - case insensitive. When the left operand is a collection, returns values from the collection that are greater than or equal to the right operand, otherwise returns TRUE if the left operand is greater than or equal to the right operand..
    /// </summary>
    internal static string igeOperatorDescription {
        get {
            return ResourceManager.GetString("igeOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Greater than - case insensitive. When the left operand is a collection, returns values from the collection that are greater than the right operand, otherwise returns TRUE if the left operand is greater than the right operand..
    /// </summary>
    internal static string igtOperatorDescription {
        get {
            return ResourceManager.GetString("igtOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case insensitive. Returns TRUE when the test value (left operand) exactly matches at least one of the values in the right operand..
    /// </summary>
    internal static string iinOperatorDescription {
        get {
            return ResourceManager.GetString("iinOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Less than or equal to - case insensitive. When the left operand is a collection, returns values from the collection that are less than or equal to the right operand, otherwise returns TRUE if the left operand is less than or equal to the right operand..
    /// </summary>
    internal static string ileOperatorDescription {
        get {
            return ResourceManager.GetString("ileOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Wildcard matching operator - case insensitive. When the left operand is a collection, returns values from the collection that match the right hand operand, otherwise returns TRUE if the left operand matches the right operand..
    /// </summary>
    internal static string ilikeOperatorDescription {
        get {
            return ResourceManager.GetString("ilikeOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Less than - case insensitive. When the left operand is a collection, returns values from the collection that are less than the right operand, otherwise returns TRUE if the left operand is less than the right operand..
    /// </summary>
    internal static string iltOperatorDescription {
        get {
            return ResourceManager.GetString("iltOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Regular expression matching operator - case insensitive. When the left operand is a collection, returns values from the collection that match the right hand operand, otherwise returns TRUE if the left operand matches the right operand..
    /// </summary>
    internal static string imatchOperatorDescription {
        get {
            return ResourceManager.GetString("imatchOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Not equal to - case insensitive. When the left operand is a collection, returns values from the collection that do not equal the right operand, otherwise returns TRUE if the left operand does not equal the right operand..
    /// </summary>
    internal static string ineOperatorDescription {
        get {
            return ResourceManager.GetString("ineOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case insensitive. Returns TRUE when the test value (left operand) exactly matches at least one of the values in the right operand..
    /// </summary>
    internal static string inOperatorDescription {
        get {
            return ResourceManager.GetString("inOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case insensitive. Returns TRUE when the test value (right operand) exactly matches none of the values in the left operand..
    /// </summary>
    internal static string inotcontainsOperatorDescription {
        get {
            return ResourceManager.GetString("inotcontainsOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case insensitive. Returns TRUE when the test value (left operand) exactly matches none of the values in the right operand..
    /// </summary>
    internal static string inotinOperatorDescription {
        get {
            return ResourceManager.GetString("inotinOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Wildcard matching operator - case insensitive. When the left operand is a collection, returns values from the collection that do not match the right hand operand, otherwise returns TRUE if the left operand does not match the right operand..
    /// </summary>
    internal static string inotlikeOperatorDescription {
        get {
            return ResourceManager.GetString("inotlikeOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Regular expression matching operator - case insensitive. When the left operand is a collection, returns values from the collection that do not match the right hand operand, otherwise returns TRUE if the left operand does not match the right operand..
    /// </summary>
    internal static string inotmatchOperatorDescription {
        get {
            return ResourceManager.GetString("inotmatchOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Replace operator - case insensitive. Changes the left operand. Example: (dir *.ps1).FullName -replace &apos;.ps1$&apos;,&apos;.ps1.bak&apos;.
    /// </summary>
    internal static string ireplaceOperatorDescription {
        get {
            return ResourceManager.GetString("ireplaceOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Returns TRUE when the left operand is not an instance of the specified .NET Framework type (right operand)..
    /// </summary>
    internal static string isnotOperatorDescription {
        get {
            return ResourceManager.GetString("isnotOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Returns TRUE when the left operand is an instance of the specified .NET Framework type (right operand)..
    /// </summary>
    internal static string isOperatorDescription {
        get {
            return ResourceManager.GetString("isOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Split - case insensitive. Split one or more strings into substrings.
    ///-Split &lt;String&gt;
    ///
    ///&lt;String&gt; -Split &lt;Delimiter&gt;[,&lt;Max-substrings&gt;[,&quot;&lt;Options&gt;&quot;]]
    ///
    ///&lt;String&gt; -Split {&lt;ScriptBlock&gt;} [,&lt;Max-substrings&gt;].
    /// </summary>
    internal static string isplitOperatorDescription {
        get {
            return ResourceManager.GetString("isplitOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Join - combine multiple strings into a single string.
    ///-Join &lt;String[]&gt;
    ///&lt;String[]&gt; -Join &lt;Delimiter&gt;.
    /// </summary>
    internal static string joinOperatorDescription {
        get {
            return ResourceManager.GetString("joinOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Less than or equal to - case insensitive. When the left operand is a collection, returns values from the collection that are less than or equal to the right operand, otherwise returns TRUE if the left operand is less than or equal to the right operand..
    /// </summary>
    internal static string leOperatorDescription {
        get {
            return ResourceManager.GetString("leOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Wildcard matching operator - case insensitive. When the left operand is a collection, returns values from the collection that match the right hand operand, otherwise returns TRUE if the left operand matches the right operand..
    /// </summary>
    internal static string likeOperatorDescription {
        get {
            return ResourceManager.GetString("likeOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Less than - case insensitive. When the left operand is a collection, returns values from the collection that are less than the right operand, otherwise returns TRUE if the left operand is less than the right operand..
    /// </summary>
    internal static string ltOperatorDescription {
        get {
            return ResourceManager.GetString("ltOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Regular expression matching operator - case insensitive. When the left operand is a collection, returns values from the collection that match the right hand operand, otherwise returns TRUE if the left operand matches the right operand..
    /// </summary>
    internal static string matchOperatorDescription {
        get {
            return ResourceManager.GetString("matchOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Not equal to - case insensitive. When the left operand is a collection, returns values from the collection that do not equal the right operand, otherwise returns TRUE if the left operand does not equal the right operand..
    /// </summary>
    internal static string neOperatorDescription {
        get {
            return ResourceManager.GetString("neOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Cannot access properties on a null instance of the type CompletionResult..
    /// </summary>
    internal static string NoAccessToProperties {
        get {
            return ResourceManager.GetString("NoAccessToProperties", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case insensitive. Returns TRUE when the test value (right operand) exactly matches none of the values in the left operand..
    /// </summary>
    internal static string notcontainsOperatorDescription {
        get {
            return ResourceManager.GetString("notcontainsOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Containment operator - case sensitive. Returns TRUE when the test value (left operand) exactly matches none of the values in the right operand..
    /// </summary>
    internal static string notinOperatorDescription {
        get {
            return ResourceManager.GetString("notinOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Wildcard matching operator - case insensitive. When the left operand is a collection, returns values from the collection that do not match the right hand operand, otherwise returns TRUE if the left operand does not match the right operand..
    /// </summary>
    internal static string notlikeOperatorDescription {
        get {
            return ResourceManager.GetString("notlikeOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Regular expression matching operator - case insensitive. When the left operand is a collection, returns values from the collection that do not match the right hand operand, otherwise returns TRUE if the left operand does not match the right operand..
    /// </summary>
    internal static string notmatchOperatorDescription {
        get {
            return ResourceManager.GetString("notmatchOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Logical not. Negates the statement that follows it..
    /// </summary>
    internal static string notOperatorDescription {
        get {
            return ResourceManager.GetString("notOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Logical or. TRUE when either or both statements are TRUE..
    /// </summary>
    internal static string orOperatorDescription {
        get {
            return ResourceManager.GetString("orOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Replace operator - case insensitive. Changes the left operand. Example: (dir *.ps1).FullName -replace &apos;.ps1$&apos;,&apos;.ps1.bak&apos;.
    /// </summary>
    internal static string replaceOperatorDescription {
        get {
            return ResourceManager.GetString("replaceOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Shift Left bit operator. Inserts zero in right-most bit position..
    /// </summary>
    internal static string shlOperatorDescription {
        get {
            return ResourceManager.GetString("shlOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Shift Right bit operator. Inserts zero in the left-most bit position. For signed values, sign bit is preserved..
    /// </summary>
    internal static string shrOperatorDescription {
        get {
            return ResourceManager.GetString("shrOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Split - case insensitive. Split one or more strings into substrings.
    ///-Split &lt;String&gt;
    ///
    ///&lt;String&gt; -Split &lt;Delimiter&gt;[,&lt;Max-substrings&gt;[,&quot;&lt;Options&gt;&quot;]]
    ///
    ///&lt;String&gt; -Split {&lt;ScriptBlock&gt;} [,&lt;Max-substrings&gt;].
    /// </summary>
    internal static string splitOperatorDescription {
        get {
            return ResourceManager.GetString("splitOperatorDescription", resourceCulture);
        }
    }
    
    /// <summary>
    ///   Looks up a localized string similar to Logical exclusive or. Returns TRUE when one of the statements is TRUE and the other is FALSE..
    /// </summary>
    internal static string xorOperatorDescription {
        get {
            return ResourceManager.GetString("xorOperatorDescription", resourceCulture);
        }
    }
}