import type { NobjcObject } from "objc-js";
import type { _NSArray } from "./NSArray.js";
import type { _NSCharacterSet } from "./NSCharacterSet.js";
import type { _NSCoder } from "./NSCoder.js";
import type { _NSCopying } from "./NSCopying.js";
import type { _NSData } from "./NSData.js";
import type { _NSDictionary } from "./NSDictionary.js";
import type { _NSItemProviderReading } from "./NSItemProviderReading.js";
import type { _NSItemProviderWriting } from "./NSItemProviderWriting.js";
import type { _NSLocale } from "./NSLocale.js";
import type { _NSMutableCopying } from "./NSMutableCopying.js";
import type { _NSObject } from "./NSObject.js";
import type { _NSOrthography } from "./NSOrthography.js";
import type { _NSURL } from "./NSURL.js";
import type { NSRange } from "../structs/NSRange.js";
import type { NSLinguisticTag } from "./NSLinguisticTag.js";
import type { NSLinguisticTagScheme } from "./NSLinguisticTagScheme.js";
import type { NSLinguisticTaggerOptions } from "./NSLinguisticTaggerOptions.js";
import type { NSStringCompareOptions } from "./NSStringCompareOptions.js";
import type { NSStringEncodingConversionOptions } from "./NSStringEncodingConversionOptions.js";
import type { NSStringEnumerationOptions } from "./NSStringEnumerationOptions.js";
export declare class _NSString extends _NSObject {
    static alloc(): _NSString;
    static new(): _NSString;
    static localizedNameOfStringEncoding$(encoding: number): _NSString;
    static string(): _NSString;
    static stringWithString$(string_: _NSString): _NSString;
    static stringWithCharacters$length$(characters: NobjcObject, length: number): _NSString;
    static stringWithUTF8String$(nullTerminatedCString: string): _NSString | null;
    static stringWithFormat$(format: _NSString): _NSString;
    static localizedStringWithFormat$(format: _NSString): _NSString;
    static stringWithValidatedFormat$validFormatSpecifiers$error$(format: _NSString, validFormatSpecifiers: _NSString, error: NobjcObject | null): _NSString | null;
    static localizedStringWithValidatedFormat$validFormatSpecifiers$error$(format: _NSString, validFormatSpecifiers: _NSString, error: NobjcObject | null): _NSString | null;
    static stringWithCString$encoding$(cString: string, enc: number): _NSString | null;
    static stringWithContentsOfURL$encoding$error$(url: _NSURL, enc: number, error: NobjcObject | null): _NSString | null;
    static stringWithContentsOfFile$encoding$error$(path: _NSString, enc: number, error: NobjcObject | null): _NSString | null;
    static stringWithContentsOfURL$usedEncoding$error$(url: _NSURL, enc: NobjcObject | null, error: NobjcObject | null): _NSString | null;
    static stringWithContentsOfFile$usedEncoding$error$(path: _NSString, enc: NobjcObject | null, error: NobjcObject | null): _NSString | null;
    /**
     * This API is used to detect the string encoding of a given raw data. It can also do lossy string conversion. It converts the data to a string in the detected string encoding. The data object contains the raw bytes, and the option dictionary contains the hints and parameters for the analysis. The opts dictionary can be nil. If the string parameter is not NULL, the string created by the detected string encoding is returned. The lossy substitution string is emitted in the output string for characters that could not be converted when lossy conversion is enabled. The usedLossyConversion indicates if there is any lossy conversion in the resulted string. If no encoding can be detected, 0 is returned. The possible items for the dictionary are: 1) an array of suggested string encodings (without specifying the 3rd option in this list, all string encodings are considered but the ones in the array will have a higher preference; moreover, the order of the encodings in the array is important: the first encoding has a higher preference than the second one in the array) 2) an array of string encodings not to use (the string encodings in this list will not be considered at all) 3) a boolean option indicating whether only the suggested string encodings are considered 4) a boolean option indicating whether lossy is allowed 5) an option that gives a specific string to substitude for mystery bytes 6) the current user's language 7) a boolean option indicating whether the data is generated by Windows If the values in the dictionary have wrong types (for example, the value of NSStringEncodingDetectionSuggestedEncodingsKey is not an array), an exception is thrown. If the values in the dictionary are unknown (for example, the value in the array of suggested string encodings is not a valid encoding), the values will be ignored.
     */
    static stringEncodingForData$encodingOptions$convertedString$usedLossyConversion$(data: _NSData, opts: _NSDictionary | null, string_: NobjcObject | null, usedLossyConversion: NobjcObject | null): number;
    /** @deprecated Use +stringWithContentsOfFile:encoding:error: instead */
    static stringWithContentsOfFile$(path: _NSString): NobjcObject | null;
    /** @deprecated Use +stringWithContentsOfURL:encoding:error: instead */
    static stringWithContentsOfURL$(url: _NSURL): NobjcObject | null;
    /** @deprecated Use +stringWithCString:encoding: */
    static stringWithCString$length$(bytes: string, length: number): NobjcObject | null;
    /** @deprecated Use +stringWithCString:encoding: instead */
    static stringWithCString$(bytes: string): NobjcObject | null;
    static pathWithComponents$(components: _NSArray): _NSString;
    static availableStringEncodings(): NobjcObject;
    /** Should be rarely used */
    static defaultCStringEncoding(): number;
    characterAtIndex$(index: number): number;
    /**
     * The initializers available to subclasses. See further below for additional init methods.
     */
    init(): _NSString;
    initWithCoder$(coder: _NSCoder): _NSString | null;
    /**
     * To avoid breaking up character sequences such as Emoji, you can do: [str substringFromIndex:[str rangeOfComposedCharacterSequenceAtIndex:index].location] [str substringToIndex:NSMaxRange([str rangeOfComposedCharacterSequenceAtIndex:index])] [str substringWithRange:[str rangeOfComposedCharacterSequencesForRange:range]
     */
    substringFromIndex$(from: number): _NSString;
    substringToIndex$(to: number): _NSString;
    /**
     * Use with rangeOfComposedCharacterSequencesForRange: to avoid breaking up character sequences
     */
    substringWithRange$(range: NSRange): _NSString;
    /**
     * Use with rangeOfComposedCharacterSequencesForRange: to avoid breaking up character sequences
     */
    getCharacters$range$(buffer: NobjcObject, range: NSRange): void;
    /**
     * In the compare: methods, the range argument specifies the subrange, rather than the whole, of the receiver to use in the comparison. The range is not applied to the search string. For example, [@"AB" compare:@"ABC" options:0 range:NSMakeRange(0,1)] compares "A" to "ABC", not "A" to "A", and will return NSOrderedAscending. It is an error to specify a range that is outside of the receiver's bounds, and an exception may be raised.
     */
    compare$(string_: _NSString): number;
    compare$options$(string_: _NSString, mask: NSStringCompareOptions): number;
    compare$options$range$(string_: _NSString, mask: NSStringCompareOptions, rangeOfReceiverToCompare: NSRange): number;
    /**
     * locale arg used to be a dictionary pre-Leopard. We now accept NSLocale. Assumes the current locale if non-nil and non-NSLocale. nil continues to mean canonical compare, which doesn't depend on user's locale choice.
     */
    compare$options$range$locale$(string_: _NSString, mask: NSStringCompareOptions, rangeOfReceiverToCompare: NSRange, locale: NobjcObject | null): number;
    caseInsensitiveCompare$(string_: _NSString): number;
    localizedCompare$(string_: _NSString): number;
    localizedCaseInsensitiveCompare$(string_: _NSString): number;
    /**
     * localizedStandardCompare:, added in 10.6, should be used whenever file names or other strings are presented in lists and tables where Finder-like sorting is appropriate. The exact behavior of this method may be tweaked in future releases, and will be different under different localizations, so clients should not depend on the exact sorting order of the strings.
     */
    localizedStandardCompare$(string_: _NSString): number;
    isEqualToString$(aString: _NSString): boolean;
    /**
     * These perform locale unaware prefix or suffix match. If you need locale awareness, use rangeOfString:options:range:locale:, passing NSAnchoredSearch (or'ed with NSBackwardsSearch for suffix, and NSCaseInsensitiveSearch|NSDiacriticInsensitiveSearch if needed) for options, NSMakeRange(0, [receiver length]) for range, and [NSLocale currentLocale] for locale.
     */
    hasPrefix$(str: _NSString): boolean;
    hasSuffix$(str: _NSString): boolean;
    commonPrefixWithString$options$(str: _NSString, mask: NSStringCompareOptions): _NSString;
    /**
     * Simple convenience methods for string searching. containsString: returns YES if the target string is contained within the receiver. Same as calling rangeOfString:options: with no options, thus doing a case-sensitive, locale-unaware search. localizedCaseInsensitiveContainsString: is the case-insensitive variant which also takes the current locale into effect. Starting in 10.11 and iOS9, the new localizedStandardRangeOfString: or localizedStandardContainsString: APIs are even better convenience methods for user level searching. More sophisticated needs can be achieved by calling rangeOfString:options:range:locale: directly.
     */
    containsString$(str: _NSString): boolean;
    localizedCaseInsensitiveContainsString$(str: _NSString): boolean;
    /**
     * The following two are the most appropriate methods for doing user-level string searches, similar to how searches are done generally in the system. The search is locale-aware, case and diacritic insensitive. As with other APIs, "standard" in the name implies "system default behavior," so the exact list of search options applied may change over time. If you need more control over the search options, please use the rangeOfString:options:range:locale: method. You can pass [NSLocale currentLocale] for searches in user's locale.
     */
    localizedStandardContainsString$(str: _NSString): boolean;
    localizedStandardRangeOfString$(str: _NSString): NSRange;
    /**
     * These methods perform string search, looking for the searchString within the receiver string. These return length==0 if the target string is not found. So, to check for containment: ([str rangeOfString:@"target"].length > 0). Note that the length of the range returned by these methods might be different than the length of the target string, due composed characters and such. Note that the first three methods do not take locale arguments, and perform the search in a non-locale aware fashion, which is not appropriate for user-level searching. To do user-level string searching, use the last method, specifying locale:[NSLocale currentLocale], or better yet, use localizedStandardRangeOfString: or localizedStandardContainsString:. The range argument specifies the subrange, rather than the whole, of the receiver to use in the search. It is an error to specify a range that is outside of the receiver's bounds, and an exception may be raised.
     */
    rangeOfString$(searchString: _NSString): NSRange;
    rangeOfString$options$(searchString: _NSString, mask: NSStringCompareOptions): NSRange;
    rangeOfString$options$range$(searchString: _NSString, mask: NSStringCompareOptions, rangeOfReceiverToSearch: NSRange): NSRange;
    rangeOfString$options$range$locale$(searchString: _NSString, mask: NSStringCompareOptions, rangeOfReceiverToSearch: NSRange, locale: _NSLocale | null): NSRange;
    /**
     * These return the range of the first character from the set in the string, not the range of a sequence of characters. The range argument specifies the subrange, rather than the whole, of the receiver to use in the search. It is an error to specify a range that is outside of the receiver's bounds, and an exception may be raised.
     */
    rangeOfCharacterFromSet$(searchSet: _NSCharacterSet): NSRange;
    rangeOfCharacterFromSet$options$(searchSet: _NSCharacterSet, mask: NSStringCompareOptions): NSRange;
    rangeOfCharacterFromSet$options$range$(searchSet: _NSCharacterSet, mask: NSStringCompareOptions, rangeOfReceiverToSearch: NSRange): NSRange;
    rangeOfComposedCharacterSequenceAtIndex$(index: number): NSRange;
    rangeOfComposedCharacterSequencesForRange$(range: NSRange): NSRange;
    stringByAppendingString$(aString: _NSString): _NSString;
    stringByAppendingFormat$(format: _NSString): _NSString;
    /**
     * The following methods perform localized case mappings based on the locale specified. Passing nil indicates the canonical mapping. For the user preference locale setting, specify +[NSLocale currentLocale].
     */
    uppercaseStringWithLocale$(locale: _NSLocale | null): _NSString;
    lowercaseStringWithLocale$(locale: _NSLocale | null): _NSString;
    capitalizedStringWithLocale$(locale: _NSLocale | null): _NSString;
    getLineStart$end$contentsEnd$forRange$(startPtr: NobjcObject | null, lineEndPtr: NobjcObject | null, contentsEndPtr: NobjcObject | null, range: NSRange): void;
    lineRangeForRange$(range: NSRange): NSRange;
    getParagraphStart$end$contentsEnd$forRange$(startPtr: NobjcObject | null, parEndPtr: NobjcObject | null, contentsEndPtr: NobjcObject | null, range: NSRange): void;
    paragraphRangeForRange$(range: NSRange): NSRange;
    /**
     * In the enumerate methods, the blocks will be invoked inside an autorelease pool, so any values assigned inside the block should be retained.
     */
    enumerateSubstringsInRange$options$usingBlock$(range: NSRange, opts: NSStringEnumerationOptions, block: ((substring: _NSString, substringRange: NSRange, enclosingRange: NSRange, stop: NobjcObject) => void) | null): void;
    enumerateLinesUsingBlock$(block: (line: _NSString, stop: NobjcObject) => void): void;
    /** External representation */
    dataUsingEncoding$allowLossyConversion$(encoding: number, lossy: boolean): _NSData | null;
    /** External representation */
    dataUsingEncoding$(encoding: number): _NSData | null;
    canBeConvertedToEncoding$(encoding: number): boolean;
    /**
     * "Autoreleased"; NULL return if encoding conversion not possible; for performance reasons, lifetime of this should not be considered longer than the lifetime of the receiving string (if the receiver string is freed, this might go invalid then, before the end of the autorelease scope). Use only with 8-bit encodings, and not encodings such as UTF-16 or UTF-32.
     */
    cStringUsingEncoding$(encoding: number): string | null;
    /**
     * NO return if conversion not possible due to encoding errors or too small of a buffer. The buffer should include room for maxBufferCount bytes; this number should accomodate the expected size of the return value plus the NULL termination character, which this method adds. (So note that the maxLength passed to this method is one more than the one you would have passed to the deprecated getCString:maxLength:.) Use only with 8-bit encodings, and not encodings such as UTF-16 or UTF-32.
     */
    getCString$maxLength$encoding$(buffer: string, maxBufferCount: number, encoding: number): boolean;
    /**
     * Use this to convert string section at a time into a fixed-size buffer, without any allocations. Does not NULL-terminate. buffer is the buffer to write to; if NULL, this method can be used to computed size of needed buffer. maxBufferCount is the length of the buffer in bytes. It's a good idea to make sure this is at least enough to hold one character's worth of conversion. usedBufferCount is the length of the buffer used up by the current conversion. Can be NULL. encoding is the encoding to convert to. options specifies the options to apply. range is the range to convert. leftOver is the remaining range. Can be NULL. YES return indicates some characters were converted. Conversion might usually stop when the buffer fills, but it might also stop when the conversion isn't possible due to the chosen encoding.
     */
    getBytes$maxLength$usedLength$encoding$options$range$remainingRange$(buffer: Uint8Array | null, maxBufferCount: number, usedBufferCount: NobjcObject | null, encoding: number, options: NSStringEncodingConversionOptions, range: NSRange, leftover: NobjcObject | null): boolean;
    /**
     * Result in O(1) time; the estimate may be way over what's needed. Returns 0 on error (overflow)
     */
    maximumLengthOfBytesUsingEncoding$(enc: number): number;
    /**
     * Result in O(n) time; the result is exact. Returns 0 on error (cannot convert to specified encoding, or overflow)
     */
    lengthOfBytesUsingEncoding$(enc: number): number;
    componentsSeparatedByString$(separator: _NSString): _NSArray;
    componentsSeparatedByCharactersInSet$(separator: _NSCharacterSet): _NSArray;
    stringByTrimmingCharactersInSet$(set: _NSCharacterSet): _NSString;
    stringByPaddingToLength$withString$startingAtIndex$(newLength: number, padString: _NSString, padIndex: number): _NSString;
    /**
     * Returns a string with the character folding options applied. theOptions is a mask of compare flags with *InsensitiveSearch suffix.
     */
    stringByFoldingWithOptions$locale$(options: NSStringCompareOptions, locale: _NSLocale | null): _NSString;
    /**
     * Replace all occurrences of the target string in the specified range with replacement. Specified compare options are used for matching target. If NSRegularExpressionSearch is specified, the replacement is treated as a template, as in the corresponding NSRegularExpression methods, and no other options can apply except NSCaseInsensitiveSearch and NSAnchoredSearch.
     */
    stringByReplacingOccurrencesOfString$withString$options$range$(target: _NSString, replacement: _NSString, options: NSStringCompareOptions, searchRange: NSRange): _NSString;
    /**
     * Replace all occurrences of the target string with replacement. Invokes the above method with 0 options and range of the whole string.
     */
    stringByReplacingOccurrencesOfString$withString$(target: _NSString, replacement: _NSString): _NSString;
    /** Replace characters in range with the specified string, returning new string. */
    stringByReplacingCharactersInRange$withString$(range: NSRange, replacement: _NSString): _NSString;
    /** Returns nil if reverse not applicable or transform is invalid */
    stringByApplyingTransform$reverse$(transform: _NSString, reverse: boolean): _NSString | null;
    /**
     * Write to specified url or path using the specified encoding. The optional error return is to indicate file system or encoding errors.
     */
    writeToURL$atomically$encoding$error$(url: _NSURL, useAuxiliaryFile: boolean, enc: number, error: NobjcObject | null): boolean;
    writeToFile$atomically$encoding$error$(path: _NSString, useAuxiliaryFile: boolean, enc: number, error: NobjcObject | null): boolean;
    /**
     * In general creation methods in NSString do not apply to subclassers, as subclassers are assumed to provide their own init methods which create the string in the way the subclass wishes. Designated initializers of NSString are thus init and initWithCoder:.
     */
    initWithCharactersNoCopy$length$freeWhenDone$(characters: NobjcObject, length: number, freeBuffer: boolean): _NSString;
    /**
     * - (instancetype)initWithCharactersNoCopy:(unichar *)characters length:(NSUInteger)length freeWhenDone:(BOOL)freeBuffer; "NoCopy" is a hint
     */
    initWithCharactersNoCopy$length$deallocator$(chars: NobjcObject, len: number, deallocator: ((arg0: NobjcObject, arg1: number) => void) | null): _NSString;
    initWithCharacters$length$(characters: NobjcObject, length: number): _NSString;
    initWithUTF8String$(nullTerminatedCString: string): _NSString | null;
    initWithString$(aString: _NSString): _NSString;
    initWithFormat$(format: _NSString): _NSString;
    initWithFormat$arguments$(format: _NSString, argList: NobjcObject): _NSString;
    initWithFormat$locale$(format: _NSString, locale: NobjcObject | null): _NSString;
    initWithFormat$locale$arguments$(format: _NSString, locale: NobjcObject | null, argList: NobjcObject): _NSString;
    initWithValidatedFormat$validFormatSpecifiers$error$(format: _NSString, validFormatSpecifiers: _NSString, error: NobjcObject | null): _NSString | null;
    initWithValidatedFormat$validFormatSpecifiers$locale$error$(format: _NSString, validFormatSpecifiers: _NSString, locale: NobjcObject | null, error: NobjcObject | null): _NSString | null;
    initWithValidatedFormat$validFormatSpecifiers$arguments$error$(format: _NSString, validFormatSpecifiers: _NSString, argList: NobjcObject, error: NobjcObject | null): _NSString | null;
    initWithValidatedFormat$validFormatSpecifiers$locale$arguments$error$(format: _NSString, validFormatSpecifiers: _NSString, locale: NobjcObject | null, argList: NobjcObject, error: NobjcObject | null): _NSString | null;
    initWithData$encoding$(data: _NSData, encoding: number): _NSString | null;
    initWithBytes$length$encoding$(bytes: Uint8Array, len: number, encoding: number): _NSString | null;
    initWithBytesNoCopy$length$encoding$freeWhenDone$(bytes: Uint8Array, len: number, encoding: number, freeBuffer: boolean): _NSString | null;
    /**
     * - (nullable instancetype)initWithBytesNoCopy:(void *)bytes length:(NSUInteger)len encoding:(NSStringEncoding)encoding freeWhenDone:(BOOL)freeBuffer; "NoCopy" is a hint
     */
    initWithBytesNoCopy$length$encoding$deallocator$(bytes: Uint8Array, len: number, encoding: number, deallocator: ((arg0: NobjcObject, arg1: number) => void) | null): _NSString | null;
    initWithCString$encoding$(nullTerminatedCString: string, encoding: number): _NSString | null;
    /**
     * These use the specified encoding. If nil is returned, the optional error return indicates problem that was encountered (for instance, file system or encoding errors).
     */
    initWithContentsOfURL$encoding$error$(url: _NSURL, enc: number, error: NobjcObject | null): _NSString | null;
    initWithContentsOfFile$encoding$error$(path: _NSString, enc: number, error: NobjcObject | null): _NSString | null;
    /**
     * These try to determine the encoding, and return the encoding which was used. Note that these methods might get "smarter" in subsequent releases of the system, and use additional techniques for recognizing encodings. If nil is returned, the optional error return indicates problem that was encountered (for instance, file system or encoding errors).
     */
    initWithContentsOfURL$usedEncoding$error$(url: _NSURL, enc: NobjcObject | null, error: NobjcObject | null): _NSString | null;
    initWithContentsOfFile$usedEncoding$error$(path: _NSString, enc: NobjcObject | null, error: NobjcObject | null): _NSString | null;
    /**
     * These methods are no longer recommended since they do not work with property lists and strings files in binary plist format. Please use the APIs in NSPropertyList.h instead.
     */
    propertyList(): NobjcObject;
    propertyListFromStringsFileFormat(): _NSDictionary | null;
    /**
     * The following methods are deprecated and will be removed from this header file in the near future. These methods use NSString.defaultCStringEncoding as the encoding to convert to, which means the results depend on the user's language and potentially other settings. This might be appropriate in some cases, but often these methods are misused, resulting in issues when running in languages other then English. UTF8String in general is a much better choice when converting arbitrary NSStrings into 8-bit representations. Additional potential replacement methods are being introduced in NSString as appropriate.
     * @deprecated Use -cStringUsingEncoding: instead
     */
    cString(): string | null;
    /** @deprecated Use -cStringUsingEncoding: instead */
    lossyCString(): string | null;
    /** @deprecated Use -lengthOfBytesUsingEncoding: instead */
    cStringLength(): number;
    /** @deprecated Use -getCString:maxLength:encoding: instead */
    getCString$(bytes: string): void;
    /** @deprecated Use -getCString:maxLength:encoding: instead */
    getCString$maxLength$(bytes: string, maxLength: number): void;
    /** @deprecated Use -getCString:maxLength:encoding: instead */
    getCString$maxLength$range$remainingRange$(bytes: string, maxLength: number, aRange: NSRange, leftoverRange: NobjcObject | null): void;
    /** @deprecated Use -writeToFile:atomically:encoding:error: instead */
    writeToFile$atomically$(path: _NSString, useAuxiliaryFile: boolean): boolean;
    /** @deprecated Use -writeToURL:atomically:encoding:error: instead */
    writeToURL$atomically$(url: _NSURL, atomically: boolean): boolean;
    /** @deprecated Use -initWithContentsOfFile:encoding:error: instead */
    initWithContentsOfFile$(path: _NSString): NobjcObject | null;
    /** @deprecated Use -initWithContentsOfURL:encoding:error: instead */
    initWithContentsOfURL$(url: _NSURL): NobjcObject | null;
    /** @deprecated Use -initWithCString:encoding: instead */
    initWithCStringNoCopy$length$freeWhenDone$(bytes: string, length: number, freeBuffer: boolean): NobjcObject | null;
    /** @deprecated Use -initWithCString:encoding: instead */
    initWithCString$length$(bytes: string, length: number): NobjcObject | null;
    /** @deprecated Use -initWithCString:encoding: instead */
    initWithCString$(bytes: string): NobjcObject | null;
    /**
     * This method is unsafe because it could potentially cause buffer overruns. You should use -getCharacters:range: instead.
     */
    getCharacters$(buffer: NobjcObject): void;
    /**
     * For strings with length variations, such as from a stringsdict file, this method returns the variant at the given width. If there is no variant at the given width, the one for the next smaller width is returned. And if there are none smaller, the smallest available is returned. For strings without variations, this method returns self. The unit that width is expressed in is decided by the application or framework. But it is intended to be some measurement indicative of the context a string would fit best to avoid truncation and wasted space.
     */
    variantFittingPresentationWidth$(width: number): _NSString;
    stringByAppendingPathComponent$(str: _NSString): _NSString;
    stringByAppendingPathExtension$(str: _NSString): _NSString | null;
    stringsByAppendingPaths$(paths: _NSArray): _NSArray;
    completePathIntoString$caseSensitive$matchesIntoArray$filterTypes$(outputName: NobjcObject | null, flag: boolean, outputArray: NobjcObject | null, filterTypes: _NSArray | null): number;
    getFileSystemRepresentation$maxLength$(cname: string, max: number): boolean;
    /**
     * Returns a new string made from the receiver by replacing all characters not in the allowedCharacters set with percent encoded characters. UTF-8 encoding is used to determine the correct percent encoded characters. Entire URL strings cannot be percent-encoded. This method is intended to percent-encode a URL component or subcomponent string, NOT the entire URL string. Any characters in allowedCharacters outside of the 7-bit ASCII range are ignored.
     */
    stringByAddingPercentEncodingWithAllowedCharacters$(allowedCharacters: _NSCharacterSet): _NSString | null;
    /**
     * @deprecated Use -stringByAddingPercentEncodingWithAllowedCharacters: instead, which always uses the recommended UTF-8 encoding, and which encodes for a specific URL component or subcomponent since each URL component or subcomponent has different rules for what characters are valid.
     */
    stringByAddingPercentEscapesUsingEncoding$(enc: number): _NSString | null;
    /**
     * @deprecated Use -stringByRemovingPercentEncoding instead, which always uses the recommended UTF-8 encoding.
     */
    stringByReplacingPercentEscapesUsingEncoding$(enc: number): _NSString | null;
    /**
     * Clients wishing to analyze a given string once may use these NSString APIs without having to create an instance of NSLinguisticTagger. If more than one tagging operation is needed on a given string, it is more efficient to use an explicit NSLinguisticTagger instance.
     * @deprecated All NSLinguisticTagger API should be replaced with NaturalLanguage.framework API
     */
    linguisticTagsInRange$scheme$options$orthography$tokenRanges$(range: NSRange, scheme: NSLinguisticTagScheme, options: NSLinguisticTaggerOptions, orthography: _NSOrthography | null, tokenRanges: NobjcObject | null): _NSArray;
    /**
     * @deprecated All NSLinguisticTagger API should be replaced with NaturalLanguage.framework API
     */
    enumerateLinguisticTagsInRange$scheme$options$orthography$usingBlock$(range: NSRange, scheme: NSLinguisticTagScheme, options: NSLinguisticTaggerOptions, orthography: _NSOrthography | null, block: ((tag: NSLinguisticTag, tokenRange: NSRange, sentenceRange: NSRange, stop: NobjcObject) => void) | null): void;
    /**
     * NSString primitives. A minimal subclass of NSString just needs to implement these two, along with an init method appropriate for that subclass. We also recommend overriding getCharacters:range: for performance.
     */
    length(): number;
    /**
     * The following convenience methods all skip initial space characters (whitespaceSet) and ignore trailing characters. They are not locale-aware. NSScanner or NSNumberFormatter can be used for more powerful and locale-aware parsing of numbers.
     */
    doubleValue(): number;
    floatValue(): number;
    intValue(): number;
    integerValue(): number;
    longLongValue(): number;
    /**
     * Skips initial space characters (whitespaceSet), or optional -/+ sign followed by zeroes. Returns YES on encountering one of "Y", "y", "T", "t", or a digit 1-9. It ignores any trailing characters.
     */
    boolValue(): boolean;
    /**
     * The following three return the canonical (non-localized) mappings. They are suitable for programming operations that require stable results not depending on the user's locale preference. For locale-aware case mapping for strings presented to users, use the "localized" methods below.
     */
    uppercaseString(): _NSString;
    lowercaseString(): _NSString;
    capitalizedString(): _NSString;
    /**
     * The following three return the locale-aware case mappings. They are suitable for strings presented to the user.
     */
    localizedUppercaseString(): _NSString;
    localizedLowercaseString(): _NSString;
    localizedCapitalizedString(): _NSString;
    /** Convenience to return null-terminated UTF8 representation */
    UTF8String(): string;
    /** Result in O(1) time; a rough estimate */
    fastestEncoding(): number;
    /** Result in O(n) time; the encoding in which the string is most compact */
    smallestEncoding(): number;
    decomposedStringWithCanonicalMapping(): _NSString;
    precomposedStringWithCanonicalMapping(): _NSString;
    decomposedStringWithCompatibilityMapping(): _NSString;
    precomposedStringWithCompatibilityMapping(): _NSString;
    description(): _NSString;
    hash(): number;
    pathComponents(): _NSArray;
    absolutePath(): boolean;
    lastPathComponent(): _NSString;
    stringByDeletingLastPathComponent(): _NSString;
    pathExtension(): _NSString;
    stringByDeletingPathExtension(): _NSString;
    stringByAbbreviatingWithTildeInPath(): _NSString;
    stringByExpandingTildeInPath(): _NSString;
    stringByStandardizingPath(): _NSString;
    stringByResolvingSymlinksInPath(): _NSString;
    fileSystemRepresentation(): string;
    /**
     * Returns a new string made from the receiver by replacing all percent encoded sequences with the matching UTF-8 characters.
     * @deprecated Use -stringByAddingPercentEncodingWithAllowedCharacters: instead, which always uses the recommended UTF-8 encoding, and which encodes for a specific URL component or subcomponent since each URL component or subcomponent has different rules for what characters are valid.
     */
    stringByRemovingPercentEncoding(): _NSString | null;
}
export interface _NSString extends _NSCopying, _NSMutableCopying, _NSItemProviderReading, _NSItemProviderWriting {
}
