@amazon/vinyl-util 1.0.0

package/dist/types/ts4.1/util/string/string.d.ts

@@ -0,0 +1,130 @@
+import type { Maybe } from '../../util/type';
+import type { ReadonlyRecord } from '../../util/object/readonlyType';
+/**
+ * Substitutes named variable references in a string.
+ *
+ * Example:
+ * ```
+ * substitute('{fruit}, {veg}', { fruit: 'apples', veg: 'carrots' }) // 'apples, carrots'
+ * ```
+ *
+ * @param str The template string.
+ * @param variables A record of variable names to values.
+ * @param pattern A regex whose first capture group is the variable name. Defaults to `{name}`.
+ * @throws IllegalArgumentError if a referenced variable is not defined.
+ */
+export declare function substitute(str: string, variables: Readonly<Record<string, any>>, pattern?: RegExp): string;
+/**
+ * Replaces substitution tokens.
+ *
+ * Each identifier may be suffixed, within the enclosing '$' characters, with an additional format tag for number
+ * padding following the prototype: `%0[width]d`
+ * For example:
+ * 'Segment_$Time%04d$' Where the `Time` property is `42` will have a replacement value of: `Segment_0042`
+ */
+export declare function substituteIdentifiers(str: string, props: ReadonlyRecord<string, string | number>): string;
+/**
+ * Returns true if the character is one of: ' ', '\t', '\n', '\r'
+ *
+ * @param charCode The character code to test
+ */
+export declare function isWhitespaceChar(charCode: number): boolean;
+/**
+ * Predefined general xml entities
+ * https://www.w3.org/TR/2008/REC-xml-20081126/#sec-predefined-ent
+ */
+export declare const predefinedDecodeEntities: ReadonlyMap<string, string>;
+/**
+ * Replaces all specified entities with their mapped representations.
+ * For example (using {@link predefinedDecodeEntities}):
+ * ```
+ * `&lt;Hello to y&apos;all&#33;&gt;` becomes `<Hello to y'all!>`
+ * ```
+ *
+ * @param str
+ * @param namedEntities
+ */
+export declare function decodeEntities(str: string, namedEntities?: ReadonlyMap<string, string>): string;
+/**
+ * Encodes the predefined xml standard entities into their entity names.
+ *
+ * & to &amp;
+ * ' to &apos;
+ * > to &gt;
+ * < to &lt;
+ * " to &quot;
+ *
+ * @param str
+ */
+export declare function encodeEntities(str: string): string;
+/**
+ * Returns true if the two strings are equal, optionally ignoring case.
+ *
+ * @param a
+ * @param b
+ * @param ignoreCase
+ */
+export declare function eqStr(a: string | null, b: string | null, ignoreCase?: boolean): boolean;
+/**
+ * Given a single character string, returns the char code of the first character.
+ *
+ * @param str A single character string from which to get the first code point.
+ */
+export declare function char(str: string): number;
+/**
+ * Returns the substring of string after the last instance of searchString, excluding searchString.
+ * If searchString is not found, the whole string will be returned.
+ *
+ * @param string
+ * @param searchString
+ * @param caseSensitive If true (default) the search will be case-sensitive.
+ */
+export declare function substringAfterLast(string: string, searchString: string, caseSensitive?: boolean): string;
+/**
+ * Returns the substring of string before the first occurrence of searchString, excluding
+ * searchString.
+ * If searchString is not found, the whole string will be returned.
+ *
+ * @param string
+ * @param searchString
+ * @param caseSensitive If true (default) the search will be case-sensitive.
+ */
+export declare function substringBefore(string: string, searchString: string, caseSensitive?: boolean): string;
+/**
+ * Tokenizes a string into lowercase alphanumeric words.
+ *
+ * E.g. `'Amazon Music x86_64'` becomes `['amazon', 'music', 'x86', '64']`
+ *
+ * @param str
+ */
+export declare function tokenizeWords(str: string): string[];
+export declare function toLowerCase<T extends string>(str: T): Lowercase<T>;
+export declare function toUpperCase<T extends string>(str: T): Uppercase<T>;
+/**
+ * If the given string is greater than a max length, truncate the string with an indicator.
+ * Example:
+ * truncate('a very long string', 10) // 'a very ...'
+ *
+ * @param str A nullable string.
+ * @param maxLength
+ * @param indicator The string to indicate there was truncation, default is an ellipses … (U+2026)
+ * @return Returns the truncated string, or the nullish value if str is nullish.
+ */
+export declare function truncate<T extends Maybe<string>>(str: T, maxLength: number, indicator?: string): T | string;
+/**
+ * Converts a string to kebab-case.
+ *
+ * This function transforms camelCase, PascalCase, snake_case, and space-separated
+ * strings into a normalized kebab-case format. It removes non-alphanumeric characters
+ * (excluding hyphens), collapses multiple delimiters, and trims leading/trailing hyphens.
+ *
+ * @example
+ * toKebabCase("HelloWorld")         // "hello-world"
+ * toKebabCase("hello_world test")   // "hello-world-test"
+ * toKebabCase("SomeText123")        // "some-text123"
+ *
+ * @param str - The input string to convert.
+ * @returns The kebab-case version of the input.
+ */
+export declare function toKebabCase(str: string): string;
+//# sourceMappingURL=string.d.ts.map

package/dist/types/ts4.1/util/string/uid.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Returns a short unique id.
+ * Optimized for performance. (2.1M ops/s ± 0.71%)
+ * The returned value is 7-22 A-Za-z0-9 characters.
+ *
+ * The uniqueness of the returned string is the current timestamp to ms precision plus 2^53-1
+ * possible values.
+ *
+ * The odds of a collision where n is the number of UIDs created within the same millisecond:
+ * 1-((2^53-2)/(2^53-1))^C(n, 2)
+ *
+ * For 1000 UIDs created within the same millisecond the odds of a collision are:
+ * 00.0000000055%, or 1 in 550 billion.
+ */
+export declare function createShortUid(): string;
+/**
+ * @deprecated use createShortUid
+ */
+export declare const createUid: typeof createShortUid;
+//# sourceMappingURL=uid.d.ts.map

package/dist/types/ts4.1/util/type.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Distributes the value types of an array into a union.
+ */
+export type Flatten<T> = T extends readonly any[] ? T[number] : T;
+/**
+ * Property keys of an object that do not map to functions.
+ */
+export type NonFunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends (...args: any) => any ? never : K;
+}[keyof T];
+/**
+ * All primitive types.
+ */
+export type Primitive = bigint | boolean | number | string | symbol | null | undefined;
+/**
+ * An empty object, safer than using `object` type.
+ */
+export type AnyRecord = Record<never, any>;
+/**
+ * never, with a message to help explain the problem.
+ * https://github.com/microsoft/TypeScript/issues/33098
+ */
+export type Never<Message extends string> = [
+    never,
+    Message
+];
+/**
+ * A type representing any type of function.
+ */
+export type Fun = (...args: any[]) => any;
+/**
+ * Enforces that the type represents data that can be serialized via JSON.stringify.
+ */
+export type JsonCompatible<T> = unknown extends T ? never : T extends bigint | symbol | Fun ? never : T extends boolean | number | string | null | undefined | {
+    toJSON(): any;
+} ? T : T extends readonly any[] ? readonly JsonCompatible<T[number]>[] : {
+    [P in keyof T]: JsonCompatible<T[P]>;
+};
+/**
+ * A compile-time check that the given value/array/object is serializable via JSON.stringify.
+ *
+ * A value is serializable if any of these are true:
+ * - It is an object with a toJSON() function
+ * - It is an object with only serializable members.
+ * - It is an array with only serializable elements.
+ * - It is type boolean, string, number, null, or undefined.
+ */
+export declare function jsonCompatible<T>(value: JsonCompatible<T>): T;
+/**
+ * An object whose properties are all optional, and all sub-properties are optional.
+ * Note: does not convert array or tuple elements to Partial.
+ */
+export type PartialDeep<T> = T extends Fun | Primitive ? T : T extends object ? {
+    [P in keyof T]?: PartialDeep<T[P]>;
+} : T;
+/**
+ * Defines specific properties of T that are not required.
+ */
+export type PickPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Possible values `typeof` operator may return.
+ */
+export type Typeof = 'bigint' | 'boolean' | 'function' | 'number' | 'object' | 'string' | 'symbol' | 'undefined';
+/**
+ * Given a possible result from `typeof`, provides the type to the matched value.
+ */
+export type FromTypeof<T extends Typeof> = T extends 'bigint' ? bigint : T extends 'boolean' ? boolean : T extends 'function' ? Fun : T extends 'number' ? number : T extends 'object' ? object | null : T extends 'string' ? string : T extends 'symbol' ? symbol : T extends 'undefined' ? undefined : any;
+/**
+ * Extracts values from T which extends type U.
+ */
+export type ExtractValues<T, U> = Pick<T, {
+    [P in keyof T]: T[P] extends U ? P : never;
+}[keyof T]>;
+/**
+ * Excludes values from T which extends type U.
+ */
+export type ExcludeValues<T, U> = Pick<T, {
+    [P in keyof T]: T[P] extends U ? never : P;
+}[keyof T]>;
+export type Maybe<T> = T | undefined | null;
+/**
+ * Infers the element type from an Array type.
+ */
+export type ElementType<T extends readonly any[]> = T extends ReadonlyArray<infer E> ? E : never;
+/**
+ * Infers the element type from a Set type.
+ */
+export type SetElementType<T extends ReadonlySet<any>> = T extends ReadonlySet<infer E> ? E : never;
+/**
+ * Enforces type T to be in an invariant position.
+ * For example `Invariant<Square>` cannot be assigned to type `Invariant<Polygon>` or vice versa.
+ *
+ * This should be used when an interface with type parameter T needs strict invariance in addition to what the
+ * compiler can infer from use.
+ *
+ * {@link https://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)}
+ */
+export type Invariant<T> = T & Required<T> & ((input: T & Required<T>) => T & Required<T>);
+export declare function invariant<T>(): Invariant<T>;
+/**
+ * Enforces type T to be in a covariant position.
+ * For example `Invariant<Square>` can be assigned to type `Invariant<Polygon>` but not vice versa.
+ *
+ * This should be used when an interface with type parameter T does not explicitly use T in an
+ * output position, but the interface implies `out T`.
+ */
+export type Covariant<T> = () => T;
+export declare function covariant<T>(): Covariant<T>;
+/**
+ * Enforces type T to be in a covariant position.
+ * For example `Invariant<Polygon>` can be assigned to type `Invariant<Square>` but not vice versa.
+ *
+ * This should be used when an interface with type parameter T does not explicitly use T in an
+ * input position, but the interface implies `in T`.
+ */
+export type Contravariant<T> = (input: T) => void;
+export declare function contravariant<T>(): Contravariant<T>;
+/**
+ * A type which may either be a direct instance of T or a promise that resolves to T.
+ */
+export type MaybePromise<T> = PromiseLike<T> | T;
+/**
+ * Deeply excludes all keys from T extending K.
+ */
+export type OmitDeep<T, K extends keyof any> = Omit<{
+    [P in keyof T]: T[P] extends Primitive ? T[P] : OmitDeep<T[P], K>;
+}, K>;
+/**
+ * Make properties of T extending K optional.
+ */
+export type Optional<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
+/**
+ * Make properties of T extending K optional, recursively.
+ */
+export type OptionalDeep<T, K extends keyof any> = Optional<{
+    [P in keyof T]: T[P] extends Primitive ? T[P] : OptionalDeep<T[P], K>;
+}, K & keyof T>;
+/**
+ * true if T extends never, otherwise false
+ */
+export type IsNever<T> = [
+    T
+] extends [
+    never
+] ? true : false;
+/**
+ * true if T extends any, otherwise false
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Determines whether a property `P` of object type `U` is declared as optional.
+ *
+ * This checks whether the `{}` type (an empty object) is assignable to
+ * `Pick<U, P>`. In TypeScript, this is true only when `P` is marked optional
+ * using the `?` modifier in the type definition.
+ *
+ * Importantly, this detects *actual optionality* rather than checking whether
+ * the property's type includes `undefined`. For example:
+ *
+ * ```ts
+ * type A = { x?: string };               // optional
+ * type B = { x: string | undefined };    // required but allows undefined
+ *
+ * IsPropertyOptional<A, "x"> // true
+ * IsPropertyOptional<B, "x"> // false
+ * ```
+ *
+ * @template U - The object type containing the property.
+ * @template P - The key of the property to test.
+ * @returns `true` if `P` is an optional property, otherwise `false`.
+ */
+export type IsPropertyOptional<U, P extends keyof U> = AnyRecord extends Pick<U, P> ? true : false;
+//# sourceMappingURL=type.d.ts.map

package/dist/types/ts4.1/util/url/resolveUrl.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Resolves a relative URI against a base URL using string manipulation,
+ * avoiding the overhead of constructing `URL` objects.
+ *
+ * Handles the same cases as `new URL(relative, base)`:
+ * - Absolute URIs (with scheme) are returned as-is.
+ * - Protocol-relative URIs (`//host/path`) inherit the base scheme.
+ * - Absolute paths (`/path`) replace the base path.
+ * - Relative paths are resolved against the base directory.
+ *
+ * @param relative The relative (or absolute) URI to resolve.
+ * @param base The base URL string to resolve against.
+ * @returns A resolved absolute URL string.
+ */
+export declare function resolveUrl(relative: string, base: string): string;
+/**
+ * Extracts the hostname from an absolute URL string.
+ *
+ * @param url An absolute URL string (e.g. `https://example.com:8080/path`).
+ * @returns The hostname (e.g. `example.com`).
+ */
+export declare function getHostname(url: string): string;
+//# sourceMappingURL=resolveUrl.d.ts.map

package/dist/types/ts4.7/client/Version.d.ts

@@ -0,0 +1,38 @@
+import type { Comparator } from '../util/comparison/compare';
+import type { Maybe } from '../util/type';
+/**
+ * An object representing a version.
+ */
+export interface Version {
+    readonly str: string;
+    readonly major: number;
+    readonly minor: number | null;
+    readonly patch: number | null;
+    readonly build: number | null;
+}
+/**
+ * A comparator for Version objects.
+ * This strict comparator will consider 1.0.0 > 1.0. Use {@link compareVersions} if null
+ * segments should be treated as zero values.
+ * Use this comparator when stable sorting.
+ */
+export declare const compareVersionsStrict: Comparator<Version | null>;
+/**
+ * A comparator for Version objects.
+ * Unlike {@link compareVersionsStrict}, 1.0.0.0 === 1.
+ * Use this comparator when comparing two versions and order does not need to be stable.
+ */
+export declare const compareVersions: Comparator<Version | null>;
+/**
+ * Given a string containing a semver-like version string, finds and returns the parsed Version.
+ *
+ * @param str
+ */
+export declare function parseVersion(str: string): Version;
+/**
+ * Given a string containing a semver-like version string, finds and returns the parsed Version.
+ *
+ * @param str
+ */
+export declare function parseVersion(str: Maybe<string>): Version | null;
+//# sourceMappingURL=Version.d.ts.map

package/dist/types/ts4.7/client/userAgent/UserAgentInfo.d.ts

@@ -0,0 +1,36 @@
+import type { Version } from '../../client/Version';
+/**
+ * A parsed user agent.
+ */
+export interface UserAgentInfo {
+    readonly userAgent: string;
+    readonly browser: UaSystemInfo | null;
+    readonly browserLike: UaSystemInfo | null;
+    readonly device: UaDeviceInfo | null;
+    readonly os: UaSystemInfo | null;
+    readonly osLike: UaSystemInfo | null;
+}
+/**
+ * Platform or system information.
+ */
+export interface UaSystemInfo {
+    readonly name: string;
+    readonly version: Version | null;
+}
+/**
+ * Device information from the user agent.
+ */
+export interface UaDeviceInfo {
+    readonly vendor: string | null;
+    readonly model: string | null;
+    readonly type: string | null;
+}
+export declare const emptyUserAgentInfo: {
+    readonly userAgent: "";
+    readonly browser: null;
+    readonly browserLike: null;
+    readonly os: null;
+    readonly osLike: null;
+    readonly device: null;
+};
+//# sourceMappingURL=UserAgentInfo.d.ts.map

package/dist/types/ts4.7/client/userAgent/defaultUserAgentRules.d.ts

@@ -0,0 +1,94 @@
+import type { UserAgentRules } from './tokenizeUserAgent';
+/**
+ * An enumeration of operating systems that can be detected from the user agent.
+ */
+export declare enum Os {
+    ANDROID = "Android",
+    ANDROID_OSP = "Android OSP",
+    CHROME_OS = "chromeOS",
+    CHROMECAST = "Chromecast",
+    FEDORA = "Fedora",
+    FIREFOX_OS = "Firefox OS",// Firefox OS (legacy) does not have a differentiable user agent
+    FIRE_OS = "Fire OS",
+    FREE_BSD = "FreeBSD",
+    HARMONY_OS = "HarmonyOS",
+    I_OS = "iOS",
+    KAIOS = "KaiOS",// Based on the discontinued Firefox OS
+    LINUX = "Linux",
+    MAC_OS = "macOS",
+    MIUI = "MIUI",
+    ORBIS = "Orbis OS",
+    SMART_CAST = "SmartCast",
+    SYMBIAN = "Symbian",
+    TIZEN = "Tizen",
+    UBUNTU = "Ubuntu",
+    VEGA = "Vega",
+    WEB_OS = "webOS",
+    WINDOWS = "Windows",
+    WINDOWS_PHONE = "Windows Phone"
+}
+/**
+ * An enumeration of browsers that can be detected from the user agent.
+ */
+export declare enum Browser {
+    BRAVE = "Brave",
+    CHROME = "Chrome",
+    CHROME_HEADLESS = "Chrome Headless",
+    CHROMIUM = "Chromium",
+    DUCK_DUCK_GO = "DuckDuckGo",
+    EDGE_CHROMIUM = "Edge Chromium",
+    EDGE_LEGACY = "Edge Legacy",
+    ELECTRON = "Electron",
+    FIREFOX = "Firefox",
+    HUAWEI = "Huawei",
+    IE = "IE",
+    IE_MOBILE = "IE Mobile",// AKA Pocket Internet Explorer
+    OCULUS = "Oculus Browser",
+    OPENWAVE = "Openwave",
+    OPERA = "Opera",
+    OPERA_TOUCH = "Opera Touch",
+    QUARK = "Quark",
+    SILK = "Silk",
+    SAFARI = "Safari",
+    SAMSUNG_BROWSER = "Samsung Browser",
+    UC_BROWSER = "UC Browser",
+    WPE = "WPE WebKit",
+    YANDEX = "Yandex",
+    WEBKIT = "WebKit"
+}
+export declare enum DeviceVendor {
+    AMAZON = "Amazon",
+    APPLE = "Apple",
+    FACEBOOK = "Facebook",
+    GOOGLE = "Google",
+    HISENSE = "Hisense",
+    HTC = "HTC",
+    HUAWEI = "Huawei",
+    K = "K",
+    LG = "LG",
+    MEIZU = "Meizu",
+    MICROSOFT = "Microsoft",
+    MOTOROLA = "Motorola",
+    NINTENDO = "Nintendo",
+    NOKIA = "Nokia",
+    NVIDIA = "Nvidia",
+    ONE_PLUS = "OnePlus",
+    OPPO = "OPPO",
+    ROKU = "Roku",
+    SAMSUNG = "Samsung",
+    SKY = "Sky",
+    SKY_DEVICES = "SKY Devices",// Not related to the set-top boxes.
+    SONY = "Sony",
+    TESLA = "Tesla",
+    VIZIO = "VIZIO"
+}
+export declare enum DeviceType {
+    AUTOMOTIVE = "automotive",
+    CONSOLE = "console",
+    DESKTOP = "desktop",
+    SMART_TV = "smarttv",
+    MOBILE = "mobile",
+    WEARABLE = "wearable"
+}
+export declare const defaultUserAgentRules: UserAgentRules;
+//# sourceMappingURL=defaultUserAgentRules.d.ts.map

package/dist/types/ts4.7/client/userAgent/hasBrowser.d.ts

@@ -0,0 +1,26 @@
+import type { Browser } from './defaultUserAgentRules';
+import type { UserAgentInfo } from './UserAgentInfo';
+import type { Maybe } from '../../util/type';
+export interface HasBrowserOptions {
+    /**
+     * If true (default), checks both {@link UserAgentInfo.browserLike} (first) and
+     * {@link UserAgentInfo.browser} for a name match.
+     */
+    readonly checkBrowserLike?: boolean;
+    /**
+     * The parsed user agent to query. Default is the browser's parsed user agent.
+     */
+    readonly userAgentInfo?: UserAgentInfo;
+}
+/**
+ * Returns true if the current user agent matches the given browser.
+ *
+ * @param browser
+ * @param minVersionStr If provided, only returns true if the browser version is at least this version.
+ * Must be parsable by {@link parseVersion}.
+ * @param maxVersionStr If provided, only returns true if the browser version is at most this version.
+ * Must be parsable by {@link parseVersion}.
+ * @param options Additional optional configuration.
+ */
+export declare function hasBrowser(browser: Browser, minVersionStr?: Maybe<string>, maxVersionStr?: Maybe<string>, options?: HasBrowserOptions): boolean;
+//# sourceMappingURL=hasBrowser.d.ts.map

package/dist/types/ts4.7/client/userAgent/parseUserAgent.d.ts

@@ -0,0 +1,14 @@
+import type { Maybe } from '../../util/type';
+import type { UserAgentRules } from './tokenizeUserAgent';
+import type { UserAgentInfo } from './UserAgentInfo';
+/**
+ * Parses the user agent into a {@link UserAgentInfo} object.
+ *
+ * @param userAgent The User Agent. Default: `navigator.userAgent`.
+ * @param rules The user agent rules.
+ */
+export declare function parseUserAgent(userAgent?: Maybe<string>, rules?: UserAgentRules): UserAgentInfo;
+export declare const userAgentInfoRef: import("../../global/globalRegistry").GlobalRef<UserAgentInfo>;
+export declare function getUserAgentInfo(): UserAgentInfo;
+export declare function setUserAgent(value: string): void;
+//# sourceMappingURL=parseUserAgent.d.ts.map

package/dist/types/ts4.7/client/userAgent/tokenizeUserAgent.d.ts

@@ -0,0 +1,104 @@
+import type { Maybe } from '../../util/type';
+import type { Version } from '../../client/Version';
+import type { UaDeviceInfo, UaSystemInfo } from './UserAgentInfo';
+/**
+ * Builds a tokenized user agent for faster queries.
+ *
+ * @param userAgent
+ */
+export declare function tokenizeUserAgent(userAgent: string): TokenizedUserAgent;
+/**
+ * A User Agent rule takes a tokenized user agent, and if the rule matches, returns the Browser
+ * or Platform
+ * information. Otherwise, returns null.
+ */
+export type SystemInfoRule = (tokenizedUa: TokenizedUserAgent) => UaSystemInfo | null;
+/**
+ * A User Agent rule takes a tokenized user agent, and if the rule matches, returns the Device
+ * information. Otherwise, returns null.
+ */
+export type DeviceInfoRule = (tokenizedUa: TokenizedUserAgent) => UaDeviceInfo | null;
+/**
+ * A User Agent rule takes a tokenized user agent, and if the rule matches, returns the Browser
+ * or Platform
+ * information. Otherwise, returns null.
+ */
+export type SystemInfoLikeRule = (tokenizedUa: TokenizedUserAgent, systemInfo: UaSystemInfo | null) => UaSystemInfo | null;
+/**
+ * The ruleset to use when parsing a user agent.
+ * Rules are expected to be from most specific to least.
+ */
+export interface UserAgentRules {
+    readonly browserRules: readonly SystemInfoRule[];
+    readonly browserLikeRules: readonly SystemInfoLikeRule[];
+    readonly osRules: readonly SystemInfoRule[];
+    readonly osLikeRules: readonly SystemInfoLikeRule[];
+    readonly deviceRules: readonly DeviceInfoRule[];
+}
+/**
+ * A tokenized user agent.
+ * A common format for user agents:
+ * `Mozilla/5.0 (<system-information>) <platform> (<platform-details>) [extensions]`
+ *
+ */
+export interface TokenizedUserAgent {
+    /**
+     * The original user agent.
+     */
+    readonly userAgent: string;
+    /**
+     * The tokenized system and platform details or extensions (parts within parenthetical sections
+     * separated by semicolons.)
+     */
+    readonly system: TokenizedInfo;
+    /**
+     * The tokenized platform info (parts outside parenthetical sections, separated by
+     * whitespace.)
+     */
+    readonly platform: TokenizedInfo;
+}
+/**
+ * A parsed system or extension part of the user agent. (A section within a parenthetical)
+ */
+export interface UserAgentPart extends UaSystemInfo {
+    readonly name: string;
+    readonly version: Version | null;
+    readonly tokens: readonly string[];
+}
+export declare class TokenizedInfo {
+    readonly parts: UserAgentPart[];
+    /**
+     * A token map of lowercase token strings to name/version pairs.
+     */
+    private readonly tokenMap;
+    constructor(parts: UserAgentPart[]);
+    /**
+     * Given lowercase tokens of only alpha characters, returns the mapped token part if all tokens
+     * are contained in the section.
+     */
+    get(...tokens: readonly string[]): UaSystemInfo | null;
+    /**
+     * Given an expression of logical operators, returns the name and version of the part
+     * that matches the expression.
+     *
+     * Logical operators currently supported: | for OR and & for AND.
+     * Operands between operators will be tokenized via {@link tokenizeWords}.
+     *
+     * @param expr The expression of tokens and operators. Example: 'windows phone|windows&mobile'
+     * will match when one part has both 'windows' and 'phone' or there are two parts, one with
+     * 'windows' and another part with 'mobile'
+     * (Case insensitive)
+     */
+    query(expr: string): UaSystemInfo | null;
+}
+/**
+ * Executes a logical expression mapping tokens with a predicate, using the result as operands.
+ *
+ * Logical operators currently supported: | for OR and & for AND.
+ * Operands between operators will be tokenized via {@link tokenizeWords}.
+ *
+ * @param expr The expression of tokens and operators.
+ * @param predicate Each token set operand will be mapped using this function.
+ */
+export declare function tokenQuery<T>(expr: string, predicate: (tokens: readonly string[]) => Maybe<T>): T | null;
+//# sourceMappingURL=tokenizeUserAgent.d.ts.map