@socketsecurity/lib 5.14.0 → 5.16.0

package/dist/cacache.d.ts

@@ -32,6 +32,12 @@ export interface RemoveOptions {
 }
 /**
  * Get the cacache module for cache operations.
+ *
+ * @example
+ * ```typescript
+ * const cacache = getCacache()
+ * const entries = await cacache.ls(cacheDir)
+ * ```
  */
 export declare function getCacache(): import("./external/cacache").CacacheInstance;
 /**
@@ -64,12 +70,23 @@ export declare function clear(options?: RemoveOptions | undefined): Promise<numb
  * Get data from the Socket shared cache by key.
  * @throws {Error} When cache entry is not found.
  * @throws {TypeError} If key contains wildcards (*)
+ *
+ * @example
+ * ```typescript
+ * const entry = await get('socket-sdk:scans:abc123')
+ * console.log(entry.data.toString('utf8'))
+ * ```
  */
 export declare function get(key: string, options?: GetOptions | undefined): Promise<CacheEntry>;
 /**
  * Put data into the Socket shared cache with a key.
  *
  * @throws {TypeError} If key contains wildcards (*)
+ *
+ * @example
+ * ```typescript
+ * await put('socket-sdk:scans:abc123', Buffer.from('result data'))
+ * ```
  */
 export declare function put(key: string, data: string | Buffer, options?: PutOptions | undefined): Promise<{
     integrity: string;
@@ -79,13 +96,34 @@ export declare function put(key: string, data: string | Buffer, options?: PutOpt
  * Remove an entry from the Socket shared cache by key.
  *
  * @throws {TypeError} If key contains wildcards (*)
+ *
+ * @example
+ * ```typescript
+ * await remove('socket-sdk:scans:abc123')
+ * ```
  */
 export declare function remove(key: string): Promise<unknown>;
 /**
  * Get data from the Socket shared cache by key without throwing.
+ *
+ * @example
+ * ```typescript
+ * const entry = await safeGet('socket-sdk:scans:abc123')
+ * if (entry) {
+ *   console.log(entry.data.toString('utf8'))
+ * }
+ * ```
  */
 export declare function safeGet(key: string, options?: GetOptions | undefined): Promise<CacheEntry | undefined>;
 /**
  * Execute a callback with a temporary directory for cache operations.
+ *
+ * @example
+ * ```typescript
+ * const result = await withTmp(async (tmpDir) => {
+ *   // Use tmpDir for temporary cache work
+ *   return 'done'
+ * })
+ * ```
  */
 export declare function withTmp<T>(callback: (tmpDirPath: string) => Promise<T>): Promise<T>;

package/dist/cache-with-ttl.d.ts

@@ -129,5 +129,12 @@ export interface TtlCache {
 }
 /**
  * Create a TTL-based cache instance.
+ *
+ * @example
+ * ```typescript
+ * const cache = createTtlCache({ ttl: 60_000, prefix: 'my-app' })
+ * await cache.set('key', { value: 42 })
+ * const data = await cache.get('key') // { value: 42 }
+ * ```
  */
 export declare function createTtlCache(options?: TtlCacheOptions): TtlCache;

package/dist/colors.d.ts

@@ -26,6 +26,12 @@ export type ColorValue = ColorName | ColorRgb;
  * Type guard to check if a color value is an RGB tuple.
  * @param value - Color value to check
  * @returns `true` if value is an RGB tuple, `false` if it's a color name
+ *
+ * @example
+ * ```typescript
+ * isRgbTuple([255, 0, 0]) // true
+ * isRgbTuple('red')       // false
+ * ```
  */
 export declare function isRgbTuple(value: ColorValue): value is ColorRgb;
 /**
@@ -33,5 +39,11 @@ export declare function isRgbTuple(value: ColorValue): value is ColorRgb;
  * Named colors are looked up in the `colorToRgb` map, RGB tuples are returned as-is.
  * @param color - Color name or RGB tuple
  * @returns RGB tuple with values 0-255
+ *
+ * @example
+ * ```typescript
+ * toRgb('red')       // [255, 0, 0]
+ * toRgb([0, 128, 0]) // [0, 128, 0]
+ * ```
  */
 export declare function toRgb(color: ColorValue): ColorRgb;

package/dist/cover/formatters.d.ts

@@ -1,9 +1,27 @@
 import type { FormatCoverageOptions } from './types';
 /**
  * Get emoji for coverage percentage.
+ *
+ * @example
+ * ```typescript
+ * getCoverageEmoji(95)  // ' \u{1F3AF}'
+ * getCoverageEmoji(50)  // ' \u{1F528}'
+ * ```
  */
 export declare function getCoverageEmoji(percent: number): string;
 /**
  * Format coverage data for console output.
+ *
+ * @example
+ * ```typescript
+ * const output = formatCoverage({
+ *   code: {
+ *     statements: { percent: '85.00' },
+ *     branches: { percent: '80.00' },
+ *     functions: { percent: '90.00' },
+ *     lines: { percent: '88.00' },
+ *   },
+ * })
+ * ```
  */
 export declare function formatCoverage(options: FormatCoverageOptions): string;

package/dist/debug.d.ts

@@ -36,6 +36,12 @@ declare function debugLogNs(namespacesOrOpts: NamespacesOrOptions, ...args: unkn
 declare function debugCacheNs(namespacesOrOpts: NamespacesOrOptions, operation: string, key: string, meta?: unknown | undefined): void;
 /**
  * Cache debug function with caller info.
+ *
+ * @example
+ * ```typescript
+ * debugCache('hit', 'socket-sdk:scans:abc123')
+ * debugCache('miss', 'socket-sdk:scans:xyz', { ttl: 60000 })
+ * ```
  */
 /*@__NO_SIDE_EFFECTS__*/
 export declare function debugCache(operation: string, key: string, meta?: unknown | undefined): void;

package/dist/dlx/binary.d.ts

@@ -113,10 +113,28 @@ export interface DlxMetadata {
 }
 /**
  * Clean expired entries from the DLX cache.
+ *
+ * @example
+ * ```typescript
+ * // Remove cache entries older than the default TTL
+ * const removed = await cleanDlxCache()
+ *
+ * // Remove entries older than 1 hour
+ * const removed2 = await cleanDlxCache(60 * 60 * 1000)
+ * ```
  */
 export declare function cleanDlxCache(maxAge?: number): Promise<number>;
 /**
  * Download and execute a binary from a URL with caching.
+ *
+ * @example
+ * ```typescript
+ * const result = await dlxBinary(['--version'], {
+ *   url: 'https://example.com/tool-linux-x64',
+ *   name: 'tool',
+ * })
+ * await result.spawnPromise
+ * ```
  */
 export declare function dlxBinary(args: readonly string[] | string[], options?: DlxBinaryOptions | undefined, spawnExtra?: SpawnExtra | undefined): Promise<DlxBinaryResult>;
 /**
@@ -124,6 +142,15 @@ export declare function dlxBinary(args: readonly string[] | string[], options?:
  * Similar to downloadPackage from dlx-package.
  *
  * @returns Object containing the path to the cached binary and whether it was downloaded
+ *
+ * @example
+ * ```typescript
+ * const { binaryPath, downloaded } = await downloadBinary({
+ *   url: 'https://example.com/tool-linux-x64',
+ *   name: 'tool',
+ * })
+ * console.log(`Binary at: ${binaryPath}, fresh: ${downloaded}`)
+ * ```
  */
 export declare function downloadBinary(options: Omit<DlxBinaryOptions, 'spawnOptions'>): Promise<{
     binaryPath: string;
@@ -139,6 +166,15 @@ export declare function downloadBinary(options: Omit<DlxBinaryOptions, 'spawnOpt
  * - integrity: SRI format sha512-<base64> (verified post-download)
  *
  * The sha256 option is preferred as it fails early during download if the checksum doesn't match.
+ *
+ * @example
+ * ```typescript
+ * const integrity = await downloadBinaryFile(
+ *   'https://example.com/tool-linux-x64',
+ *   '/tmp/dlx-cache/tool'
+ * )
+ * console.log(`Integrity: ${integrity}`)
+ * ```
  */
 export declare function downloadBinaryFile(url: string, destPath: string, integrity?: string | undefined, sha256?: string | undefined): Promise<string>;
 /**
@@ -151,24 +187,61 @@ export declare function downloadBinaryFile(url: string, destPath: string, integr
  * @param spawnOptions Spawn options for execution
  * @param spawnExtra Extra spawn configuration
  * @returns The spawn promise for the running process
+ *
+ * @example
+ * ```typescript
+ * const { binaryPath } = await downloadBinary({
+ *   url: 'https://example.com/tool-linux-x64',
+ *   name: 'tool',
+ * })
+ * const result = executeBinary(binaryPath, ['--help'])
+ * ```
  */
 export declare function executeBinary(binaryPath: string, args: readonly string[] | string[], spawnOptions?: SpawnOptions | undefined, spawnExtra?: SpawnExtra | undefined): ReturnType<typeof spawn>;
 /**
  * Get the DLX binary cache directory path.
  * Returns normalized path for cross-platform compatibility.
  * Uses same directory as dlx-package for unified DLX storage.
+ *
+ * @example
+ * ```typescript
+ * const cachePath = getDlxCachePath()
+ * ```
  */
 export declare function getDlxCachePath(): string;
 /**
  * Get metadata file path for a cached binary.
+ *
+ * @example
+ * ```typescript
+ * const metaPath = getBinaryCacheMetadataPath('/tmp/dlx-cache/a1b2c3d4')
+ * // '/tmp/dlx-cache/a1b2c3d4/.dlx-metadata.json'
+ * ```
  */
 export declare function getBinaryCacheMetadataPath(cacheEntryPath: string): string;
 /**
  * Check if a cached binary is still valid.
+ *
+ * @example
+ * ```typescript
+ * const ttl = 7 * 24 * 60 * 60 * 1000
+ * const valid = await isBinaryCacheValid('/tmp/dlx-cache/a1b2c3d4', ttl)
+ * if (!valid) {
+ *   // Re-download the binary
+ * }
+ * ```
  */
 export declare function isBinaryCacheValid(cacheEntryPath: string, cacheTtl: number): Promise<boolean>;
 /**
  * Get information about cached binaries.
+ *
+ * @example
+ * ```typescript
+ * const entries = await listDlxCache()
+ * for (const entry of entries) {
+ *   console.log(`${entry.name}: ${entry.size} bytes`)
+ * }
+ * ```
  */
 export declare function listDlxCache(): Promise<Array<{
     age: number;
@@ -181,5 +254,16 @@ export declare function listDlxCache(): Promise<Array<{
  * Write metadata for a cached binary.
  * Uses unified schema shared with C++ decompressor and CLI dlxBinary.
  * Schema documentation: See DlxMetadata interface in this file (exported).
+ *
+ * @example
+ * ```typescript
+ * await writeBinaryCacheMetadata(
+ *   '/tmp/dlx-cache/a1b2c3d4',
+ *   'a1b2c3d4',
+ *   'https://example.com/tool',
+ *   'sha512-abc123...',
+ *   15000000
+ * )
+ * ```
  */
 export declare function writeBinaryCacheMetadata(cacheEntryPath: string, cacheKey: string, url: string, integrity: string, size: number): Promise<void>;

package/dist/dlx/cache.d.ts

@@ -21,5 +21,11 @@
  * https://github.com/npm/cli/blob/v11.6.2/workspaces/libnpmexec/lib/index.js#L233-L244
  * Implementation: packages.map().sort().join('\n') → SHA-512 → slice(0,16)
  * npx hashes the package spec (name@version), not just name
+ *
+ * @example
+ * ```typescript
+ * const key = generateCacheKey('prettier@3.0.0')
+ * // e.g. 'a1b2c3d4e5f67890'
+ * ```
  */
 export declare function generateCacheKey(spec: string): string;

package/dist/dlx/detect.d.ts

@@ -11,6 +11,12 @@ export interface ExecutableDetectionResult {
  *
  * @param filePath - Path within DLX cache (~/.socket/_dlx/)
  * @returns Detection result
+ *
+ * @example
+ * ```typescript
+ * const result = detectDlxExecutableType('/tmp/.socket/_dlx/a1b2c3d4/tool')
+ * console.log(result.type) // 'package' or 'binary'
+ * ```
  */
 export declare function detectDlxExecutableType(filePath: string): ExecutableDetectionResult;
 /**
@@ -41,6 +47,14 @@ export declare function detectExecutableType(filePath: string): ExecutableDetect
  *
  * @param filePath - Local filesystem path (not in DLX cache)
  * @returns Detection result
+ *
+ * @example
+ * ```typescript
+ * const result = detectLocalExecutableType('/usr/local/bin/tool')
+ * if (result.type === 'package') {
+ *   console.log('Node.js package at:', result.packageJsonPath)
+ * }
+ * ```
  */
 export declare function detectLocalExecutableType(filePath: string): ExecutableDetectionResult;
 /**
@@ -48,6 +62,13 @@ export declare function detectLocalExecutableType(filePath: string): ExecutableD
  *
  * @param filePath - Path to check
  * @returns True if file has .js, .mjs, or .cjs extension
+ *
+ * @example
+ * ```typescript
+ * isJsFilePath('index.js')   // true
+ * isJsFilePath('lib.mjs')    // true
+ * isJsFilePath('tool.exe')   // false
+ * ```
  */
 export declare function isJsFilePath(filePath: string): boolean;
 /**
@@ -55,6 +76,12 @@ export declare function isJsFilePath(filePath: string): boolean;
  *
  * @param filePath - Path to check
  * @returns True if detected as native binary (not Node.js package)
+ *
+ * @example
+ * ```typescript
+ * isNativeBinary('/usr/local/bin/tool')    // true
+ * isNativeBinary('/tmp/project/index.js')  // false
+ * ```
  */
 export declare function isNativeBinary(filePath: string): boolean;
 /**
@@ -62,5 +89,11 @@ export declare function isNativeBinary(filePath: string): boolean;
  *
  * @param filePath - Path to check
  * @returns True if detected as Node.js package
+ *
+ * @example
+ * ```typescript
+ * isNodePackage('/tmp/project/index.js')   // true
+ * isNodePackage('/usr/local/bin/tool')     // false
+ * ```
  */
 export declare function isNodePackage(filePath: string): boolean;

package/dist/dlx/dir.d.ts

@@ -1,24 +1,58 @@
 /**
  * Clear all DLX package installations.
+ *
+ * @example
+ * ```typescript
+ * await clearDlx()
+ * ```
  */
 export declare function clearDlx(): Promise<void>;
 /**
  * Clear all DLX package installations synchronously.
+ *
+ * @example
+ * ```typescript
+ * clearDlxSync()
+ * ```
  */
 export declare function clearDlxSync(): void;
 /**
  * Check if the DLX directory exists.
+ *
+ * @example
+ * ```typescript
+ * if (dlxDirExists()) {
+ *   console.log('DLX directory is present')
+ * }
+ * ```
  */
 export declare function dlxDirExists(): boolean;
 /**
  * Check if the DLX directory exists asynchronously.
+ *
+ * @example
+ * ```typescript
+ * if (await dlxDirExistsAsync()) {
+ *   console.log('DLX directory is present')
+ * }
+ * ```
  */
 export declare function dlxDirExistsAsync(): Promise<boolean>;
 /**
  * Ensure the DLX directory exists, creating it if necessary.
+ *
+ * @example
+ * ```typescript
+ * await ensureDlxDir()
+ * ```
  */
 export declare function ensureDlxDir(): Promise<void>;
 /**
  * Ensure the DLX directory exists synchronously, creating it if necessary.
+ *
+ * @example
+ * ```typescript
+ * ensureDlxDirSync()
+ * ```
  */
 export declare function ensureDlxDirSync(): void;

package/dist/dlx/manifest.d.ts

@@ -57,12 +57,28 @@ export interface DlxManifestOptions {
 }
 /**
  * Type guard for binary entries.
+ *
+ * @example
+ * ```typescript
+ * const entry = manifest.getManifestEntry('https://example.com/tool')
+ * if (entry && isBinaryEntry(entry)) {
+ *   console.log(entry.details.integrity)
+ * }
+ * ```
  */
 export declare function isBinaryEntry(entry: ManifestEntry): entry is ManifestEntry & {
     details: BinaryDetails;
 };
 /**
  * Type guard for package entries.
+ *
+ * @example
+ * ```typescript
+ * const entry = manifest.getManifestEntry('@socketsecurity/cli@^2.0.0')
+ * if (entry && isPackageEntry(entry)) {
+ *   console.log(entry.details.installed_version)
+ * }
+ * ```
  */
 export declare function isPackageEntry(entry: ManifestEntry): entry is ManifestEntry & {
     details: PackageDetails;

package/dist/dlx/package.d.ts

@@ -103,6 +103,16 @@ export declare function downloadPackage(options: DlxPackageOptions): Promise<Dow
  * Install package to ~/.socket/_dlx/<hash>/ if not already installed.
  * Uses pacote for installation (no npm CLI required).
  * Protected by process lock to prevent concurrent installation corruption.
+ *
+ * @example
+ * ```typescript
+ * const { installed, packageDir } = await ensurePackageInstalled(
+ *   'prettier',
+ *   'prettier@3.0.0',
+ *   false
+ * )
+ * console.log(`Installed: ${installed}, dir: ${packageDir}`)
+ * ```
  */
 export declare function ensurePackageInstalled(packageName: string, packageSpec: string, force: boolean): Promise<{
     installed: boolean;
@@ -137,6 +147,15 @@ export declare function executePackage(binaryPath: string, args: readonly string
  * 2. Fall back to user-provided binaryName if npm's strategy fails
  * 3. Try last segment of package name as final fallback
  * 4. Use first binary as last resort
+ *
+ * @example
+ * ```typescript
+ * const binPath = findBinaryPath(
+ *   '/tmp/.socket/_dlx/a1b2c3d4',
+ *   'prettier'
+ * )
+ * console.log(`Binary: ${binPath}`)
+ * ```
  */
 export declare function findBinaryPath(packageDir: string, packageName: string, binaryName?: string): string;
 /**
@@ -152,6 +171,14 @@ export declare function findBinaryPath(packageDir: string, packageName: string,
  * References:
  * - npm cmd-shim: https://github.com/npm/cmd-shim/blob/main/lib/index.js
  * - npm getBinFromManifest: https://github.com/npm/libnpmexec/blob/main/lib/get-bin-from-manifest.js
+ *
+ * @example
+ * ```typescript
+ * makePackageBinsExecutable(
+ *   '/tmp/.socket/_dlx/a1b2c3d4',
+ *   'prettier'
+ * )
+ * ```
  */
 export declare function makePackageBinsExecutable(packageDir: string, packageName: string): void;
 /**
@@ -160,6 +187,15 @@ export declare function makePackageBinsExecutable(packageDir: string, packageNam
  * - 'lodash@4.17.21' → { name: 'lodash', version: '4.17.21' }
  * - '@scope/pkg@1.0.0' → { name: '@scope/pkg', version: '1.0.0' }
  * - 'lodash' → { name: 'lodash', version: undefined }
+ *
+ * @example
+ * ```typescript
+ * parsePackageSpec('lodash@4.17.21')
+ * // { name: 'lodash', version: '4.17.21' }
+ *
+ * parsePackageSpec('@scope/pkg')
+ * // { name: '@scope/pkg', version: undefined }
+ * ```
  */
 export declare function parsePackageSpec(spec: string): {
     name: string;
@@ -171,5 +207,12 @@ export declare function parsePackageSpec(spec: string): {
  * On Unix, uses path directly.
  *
  * Aligns with npm/npx binary resolution strategy.
+ *
+ * @example
+ * ```typescript
+ * const resolved = resolveBinaryPath('/tmp/.socket/_dlx/a1b2c3d4/prettier')
+ * // On Windows: may resolve to '.cmd' or '.ps1' wrapper
+ * // On Unix: returns the path unchanged
+ * ```
  */
 export declare function resolveBinaryPath(basePath: string): string;

package/dist/dlx/packages.d.ts

@@ -1,24 +1,60 @@
 /**
  * Check if a package is installed in DLX.
+ *
+ * @example
+ * ```typescript
+ * if (isDlxPackageInstalled('prettier')) {
+ *   console.log('prettier is installed')
+ * }
+ * ```
  */
 export declare function isDlxPackageInstalled(packageName: string): boolean;
 /**
  * Check if a package is installed in DLX asynchronously.
+ *
+ * @example
+ * ```typescript
+ * if (await isDlxPackageInstalledAsync('prettier')) {
+ *   console.log('prettier is installed')
+ * }
+ * ```
  */
 export declare function isDlxPackageInstalledAsync(packageName: string): Promise<boolean>;
 /**
  * List all packages installed in DLX.
+ *
+ * @example
+ * ```typescript
+ * const packages = listDlxPackages()
+ * console.log('Installed:', packages.join(', '))
+ * ```
  */
 export declare function listDlxPackages(): string[];
 /**
  * List all packages installed in DLX asynchronously.
+ *
+ * @example
+ * ```typescript
+ * const packages = await listDlxPackagesAsync()
+ * console.log('Installed:', packages.join(', '))
+ * ```
  */
 export declare function listDlxPackagesAsync(): Promise<string[]>;
 /**
  * Remove a DLX package installation.
+ *
+ * @example
+ * ```typescript
+ * await removeDlxPackage('prettier')
+ * ```
  */
 export declare function removeDlxPackage(packageName: string): Promise<void>;
 /**
  * Remove a DLX package installation synchronously.
+ *
+ * @example
+ * ```typescript
+ * removeDlxPackageSync('prettier')
+ * ```
  */
 export declare function removeDlxPackageSync(packageName: string): void;

package/dist/dlx/paths.d.ts

@@ -1,17 +1,37 @@
 /**
  * Get the installed package directory within DLX node_modules.
+ *
+ * @example
+ * ```typescript
+ * const dir = getDlxInstalledPackageDir('prettier')
+ * ```
  */
 export declare function getDlxInstalledPackageDir(packageName: string): string;
 /**
  * Get the DLX installation directory for a specific package.
+ *
+ * @example
+ * ```typescript
+ * const dir = getDlxPackageDir('a1b2c3d4')
+ * ```
  */
 export declare function getDlxPackageDir(packageName: string): string;
 /**
  * Get the package.json path for a DLX installed package.
+ *
+ * @example
+ * ```typescript
+ * const jsonPath = getDlxPackageJsonPath('prettier')
+ * ```
  */
 export declare function getDlxPackageJsonPath(packageName: string): string;
 /**
  * Get the node_modules directory for a DLX package installation.
+ *
+ * @example
+ * ```typescript
+ * const nmDir = getDlxPackageNodeModulesDir('a1b2c3d4')
+ * ```
  */
 export declare function getDlxPackageNodeModulesDir(packageName: string): string;
 /**

package/dist/dlx/paths.js

@@ -61,7 +61,7 @@ function isInSocketDlx(filePath) {
     return false;
   }
   const path = /* @__PURE__ */ getPath();
-  const dlxDir = (0, import_socket.getSocketDlxDir)();
+  const dlxDir = (0, import_normalize.normalizePath)((0, import_socket.getSocketDlxDir)());
   const absolutePath = (0, import_normalize.normalizePath)(path.resolve(filePath));
   return absolutePath.startsWith(`${dlxDir}/`);
 }

package/dist/effects/pulse-frames.d.ts

@@ -23,6 +23,12 @@ export type SocketFramesOptions = {
  * Returns a spinner definition compatible with cli-spinners format.
  *
  * @see https://github.com/sindresorhus/cli-spinners/blob/main/spinners.json
+ *
+ * @example
+ * ```typescript
+ * const { frames, interval } = generateSocketSpinnerFrames()
+ * console.log(frames.length, interval) // 18 50
+ * ```
  */
 export declare function generateSocketSpinnerFrames(options?: SocketFramesOptions | undefined): {
     frames: string[];

package/dist/effects/text-shimmer.d.ts

@@ -34,5 +34,14 @@ export declare const MODE_BI = "bi";
  * 4. Renders each character with appropriate brightness based on distance from wave
  * 5. Updates the animation state for the next frame
  * 6. Handles direction changes for bidirectional and random modes
+ *
+ * @example
+ * ```typescript
+ * const state = { step: 0, speed: 0.33, currentDir: 'ltr', mode: 'ltr' }
+ * const result = applyShimmer('Loading...', state, {
+ *   color: [140, 82, 255],
+ *   direction: 'ltr',
+ * })
+ * ```
  */
 export declare function applyShimmer(text: string, state: ShimmerState, options?: ShimmerOptions | undefined): string;

package/dist/effects/ultra.d.ts

@@ -12,5 +12,11 @@ export declare const RAINBOW_GRADIENT: ShimmerColorGradient;
 /**
  * Generate rainbow gradient colors for any text length.
  * Colors are distributed evenly across the text by cycling through the gradient.
+ *
+ * @example
+ * ```typescript
+ * const colors = generateRainbowGradient('Hello'.length)
+ * console.log(colors.length) // 5
+ * ```
  */
 export declare function generateRainbowGradient(textLength: number): ShimmerColorGradient;