ngx-transforms 0.0.5 → 0.2.0

package/types/ngx-transforms.d.ts

@@ -71,8 +71,6 @@ interface AsciiArtOptions extends Partial<AsciiConfig> {
  * @example
  * // With inverted colors
  * {{ 'DARK' | asciiArt:{ inverted: true, charset: CharsetPreset.MINIMAL } }}
- *
- * @author Mofiro Jean
  */
 declare class AsciiArtPipe implements PipeTransform {
     private generator;
@@ -87,6 +85,286 @@ declare class AsciiArtPipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<AsciiArtPipe, "asciiArt", true>;
 }
 
+/**
+ * CamelCasePipe: Converts text to camelCase (e.g., "hello world" → "helloWorld").
+ *
+ * @param {string} value - The input string to transform.
+ * @returns {string} The string in camelCase, or an empty string if input is invalid.
+ *
+ * @example
+ * ```html
+ * {{ 'hello world' | camelCase }} <!-- Outputs: helloWorld -->
+ * ```
+ */
+declare class CamelCasePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CamelCasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CamelCasePipe, "camelCase", true>;
+}
+
+/**
+ * HighlightPipe: Highlights occurrences of a search term within a string.
+ *
+ * This Angular pipe transforms a string input by wrapping all occurrences of a specified
+ * search term with a `<span>` element that has the class "highlight".
+ * It uses the Angular `DomSanitizer` to bypass security and render the highlighted HTML.
+ *
+ * @param {string} value - The input string in which to highlight the search term.
+ * @param {string} searchTerm - The string to search for and highlight.
+ * @returns {SafeHtml} - The input string with the search term highlighted, or an empty string if input or searchTerm are falsy.
+ *
+ * @example
+ * {{ 'This is a test string' | highlight: 'test' }} // Returns 'This is a <span class="highlight">test</span> string'
+ * {{ 'This is a test TEST string' | highlight: 'test' }} // Returns 'This is a <span class="highlight">test</span> <span class="highlight">TEST</span> string'
+ * {{ 'This is a test string' | highlight: '' }} // Returns 'This is a test string'
+ * {{ null | highlight: 'test' }} // Returns ''
+ * {{ undefined | highlight: 'test' }} // Returns ''
+ */
+declare class HighlightPipe implements PipeTransform {
+    private sanitizer;
+    transform(value: string, searchTerm: string): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HighlightPipe, "highlight", true>;
+}
+
+/**
+ * InitialsPipe: Extracts initials from a name.
+ *
+ * @param {string} value - The full name.
+ *
+ * @returns {string} - The initials (e.g., 'John Doe' → 'JD').
+ *
+ * @example
+ * {{ 'John Doe' | initials }} // Outputs: JD
+ * {{ 'Mary Jane Watson' | initials }} // Outputs: MJW
+ */
+declare class InitialsPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitialsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InitialsPipe, "initials", true>;
+}
+
+/**
+ * KebabCasePipe: Converts text to kebab-case (e.g., "hello world" → "hello-world").
+ *
+ * @param {string} value - The input string to transform.
+ * @returns {string} The string in kebab-case, or an empty string if input is invalid.
+ *
+ * @example
+ * ```html
+ * {{ 'hello world' | kebabCase }} <!-- Outputs: hello-world -->
+ * ```
+ */
+declare class KebabCasePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KebabCasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<KebabCasePipe, "kebabCase", true>;
+}
+
+/**
+ * MorseCodePipe: Converts text to Morse code.
+ *
+ * @param {string} value - The text to convert to Morse code.
+ *
+ * @returns {string} - The Morse code representation (e.g., 'SOS' → '... --- ...').
+ *
+ * @example
+ * {{ 'SOS' | morseCode }} // Outputs: '... --- ...'
+ * {{ 'HELP' | morseCode }} // Outputs: '.... . .-.. .--.'
+ * <p>{{ userInput | morseCode }}</p>
+ */
+declare class MorseCodePipe implements PipeTransform {
+    private readonly morseCodeMap;
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MorseCodePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MorseCodePipe, "morseCode", true>;
+}
+
+/**
+ * ReplacePipe: A custom Angular pipe that either highlights or replaces text based on a pattern.
+ *
+ * - If `isReplace` is `false`, it highlights occurrences of the pattern (if `highlightClass` is provided).
+ * - If `isReplace` is `true`, it replaces occurrences of the pattern with the replacement string, optionally highlighting the replacement.
+ *
+ * @param {string} value - The input string to transform.
+ * @param {string | RegExp} pattern - The pattern to match (string or RegExp). If an empty string, the value is returned as-is.
+ * @param {string} replacement - The string to replace matches with.
+ * @param {string} [highlightClass] - Optional CSS class for highlighting matched or replaced text (e.g., 'highlight').
+ * @param {boolean} [isReplace=true] - Whether to perform replacement (true) or only highlight matches (false).
+ *
+ * @returns {string | SafeHtml} - Returns the transformed string or SafeHtml with highlights.
+ */
+declare class ReplacePipe implements PipeTransform {
+    private sanitizer;
+    transform(value: string, pattern: string | RegExp, replacement: string, highlightClass?: string, isReplace?: boolean): string | SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReplacePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ReplacePipe, "replace", true>;
+}
+
+/**
+ * SnakeCasePipe: Converts text to snake_case (e.g., "hello world" → "hello_world").
+ *
+ * @param {string} value - The input string to transform.
+ * @returns {string} The string in snake_case, or an empty string if input is invalid.
+ *
+ * @example
+ * ```html
+ * {{ 'hello world' | snakeCase }} <!-- Outputs: hello_world -->
+ * ```
+ */
+declare class SnakeCasePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SnakeCasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SnakeCasePipe, "snakeCase", true>;
+}
+
+/**
+ * TitleCasePipe: Capitalizes the first letter of each word in a string.
+ *
+ * @param {string} value - The input string to transform.
+ * @returns {string} The string with each word capitalized, or an empty string if input is invalid.
+ *
+ * @example
+ * ```html
+ * {{ 'hello world' | titleCase }} <!-- Outputs: Hello World -->
+ * ```
+ */
+declare class TitleCasePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TitleCasePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TitleCasePipe, "titleCase", true>;
+}
+
+/**
+ * TruncatePipe: Truncates a string to a specified maximum length, optionally preserving words.
+ *
+ * This Angular pipe transforms a string input by truncating it to the given `maxLength`.
+ * It provides options to customize the ellipsis and preserve word boundaries.
+ *
+ * @param {string} value - The input string to be truncated.
+ * @param {number} [maxLength=10] - The maximum length of the truncated string. Defaults to 10.
+ * @param {string} [ellipsis='...'] - The string to append to the truncated portion. Defaults to '...'.
+ * @param {boolean} [preserveWords=false] - If true, truncates at the last space before `maxLength` to avoid cutting words. Defaults to false.
+ * @returns {string} - The truncated string. Returns an empty string if the input is null, undefined, or not a string.
+ *
+ * @example
+ * {{ 'This is a long sentence' | truncate }} // Returns 'This is a...'
+ * {{ 'This is a long sentence' | truncate: 20 }} // Returns 'This is a long sente...'
+ * {{ 'This is a long sentence' | truncate: 15: ' [more]' }} // Returns 'This is a long [more]'
+ * {{ 'This is a long sentence' | truncate: 15: '...' : true }} // Returns 'This is a...'
+ * {{ 'This is a long sentence' | truncate: 20: '...' : true }} // Returns 'This is a long...'
+ * {{ null | truncate }} // Returns ''
+ * {{ undefined | truncate }} // Returns ''
+ */
+declare class TruncatePipe implements PipeTransform {
+    transform(value: string, maxLength?: number, ellipsis?: string, preserveWords?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TruncatePipe, "truncate", true>;
+}
+
+/**
+ * CreditCardMaskPipe: Masks all but the last four digits of a string, optionally controlled by a boolean flag.
+ * By default, masking is applied.
+ *
+ * @param {string} value - The input string to mask (e.g., credit card number).
+ * @param {boolean} shouldMask - (Optional) Determines if masking should be applied. Defaults to true.
+ * @returns {string} - The masked string or the original value if `shouldMask` is false or the value is too short.
+ *
+ * @example
+ * {{ '1234567890123456' | creditCardMask }} // Outputs: **** **** **** 3456
+ * {{ '1234-5678-9012-3456' | creditCardMask }} // Outputs: **** **** **** 3456
+ * {{ '1234567890123456' | creditCardMask: true }} // Outputs: **** **** **** 3456
+ * {{ '1234567890123456' | creditCardMask: false }} // Outputs: 1234567890123456
+ */
+declare class CreditCardMaskPipe implements PipeTransform {
+    transform(value: string | null | undefined, shouldMask?: boolean): string | null | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreditCardMaskPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CreditCardMaskPipe, "creditCardMask", true>;
+}
+
+/**
+ * EmailMaskPipe: Masks the local part of an email address, revealing only the first and last characters.
+ *
+ * This Angular pipe transforms an email address string by replacing the characters between the first and last characters of the local part (before the '@') with "***".
+ * If the local part is 2 characters or less, it masks all characters except the first.
+ *
+ * @param {string} value - The email address string to be masked.
+ * @returns {string} - The masked email address, or the original value if it's not a valid email or falsy.
+ *
+ * @example
+ * {{ 'test@example.com' | emailMask }} // Returns 't***t@example.com'
+ * {{ 'te@example.com' | emailMask }} // Returns 't***@example.com'
+ * {{ 't@example.com' | emailMask }} // Returns 't***@example.com'
+ * {{ 'example.com' | emailMask }} // Returns 'example.com'
+ * {{ null | emailMask }} // Returns ''
+ * {{ undefined | emailMask }} // Returns ''
+ */
+declare class EmailMaskPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmailMaskPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EmailMaskPipe, "emailMask", true>;
+}
+
+/**
+ * Converts special HTML characters in a string to their corresponding HTML entities.
+ * This prevents the browser from interpreting the input as HTML, rendering it as plain text.
+ *
+ * @param {string} value - The input string containing HTML to escape.
+ * @returns {string} The string with special HTML characters escaped, or an empty string if input is invalid.
+ *
+ * @example
+ * ```html
+ * {{ '<p>Hello</p>' | htmlEscape }} <!-- Outputs: &lt;p&gt;Hello&lt;/p&gt; -->
+ * ```
+ */
+declare class HtmlEscapePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlEscapePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HtmlEscapePipe, "htmlEscape", true>;
+}
+
+/**
+ * Sanitizes HTML input to remove unsafe elements while allowing safe HTML to be rendered.
+ * Uses Angular's DomSanitizer to mark the output as trusted for use in [innerHTML].
+ *
+ * @param {string} value - The input string containing HTML to sanitize.
+ * @returns {SafeHtml} The sanitized HTML marked as safe, or an empty string if input is invalid.
+ *
+ * @remarks
+ * WARNING: Use with caution. Only apply to trusted input to avoid XSS risks.
+ * Ensure input is pre-validated or sourced from a secure origin (e.g., a controlled rich-text editor).
+ *
+ * @example
+ * ```html
+ * <div [innerHTML]="'<p>Hello</p><script>alert(1)</script>' | htmlSanitize"></div>
+ * <!-- Renders: <p>Hello</p> (script tag removed) -->
+ * ```
+ */
+declare class HtmlSanitizePipe implements PipeTransform {
+    private sanitizer;
+    transform(value: string): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlSanitizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<HtmlSanitizePipe, "htmlSanitize", true>;
+}
+
+/**
+ * IpAddressMaskPipe: Masks the last two octets of an IPv4 address.
+ *
+ * @param {string} value - The IPv4 address (e.g., 192.168.1.1).
+ * @param {boolean} shouldMask - (Optional) Determines if masking should be applied. Defaults to true..
+ *
+ * @returns {string} - The masked IP address (e.g., 192.168.*.*).
+ *
+ * @example
+ * {{ '192.168.1.1' | ipAddressMask }} // Outputs: 192.168.*.*
+ * {{ '10.0.0.255' | ipAddressMask }} // Outputs: 10.0.*.*
+ */
+declare class IpAddressMaskPipe implements PipeTransform {
+    transform(value: string, shouldMask?: boolean): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IpAddressMaskPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IpAddressMaskPipe, "ipAddressMask", true>;
+}
+
 /**
  * BarcodeElementType: Defines the type of element to render the barcode.
  *
@@ -129,8 +407,6 @@ interface BarcodeOptions {
  * @example
  * <div [innerHTML]="'123456789' | barcode:{elementType:'svg',format:'CODE128'} | async"></div>
  * <img [src]="'123456789' | barcode:{elementType:'img'} | async" />
- *
- * @author Mofiro Jean
  */
 declare class BarcodePipe implements PipeTransform {
     private sanitizer;
@@ -139,25 +415,6 @@ declare class BarcodePipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<BarcodePipe, "barcode", true>;
 }
 
-/**
- * CamelCasePipe: Converts text to camelCase (e.g., "hello world" → "helloWorld").
- *
- * @param {string} value - The input string to transform.
- * @returns {string} The string in camelCase, or an empty string if input is invalid.
- *
- * @example
- * ```html
- * {{ 'hello world' | camelCase }} <!-- Outputs: helloWorld -->
- * ```
- *
- * @author Mofiro Jean
- */
-declare class CamelCasePipe implements PipeTransform {
-    transform(value: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CamelCasePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CamelCasePipe, "camelCase", true>;
-}
-
 /**
  * ColorTargetType: Defines the target color format for conversion.
  *
@@ -207,8 +464,6 @@ type ColorTargetType = 'hex' | 'rgb' | 'rgba';
  * // Alpha channel support
  * {{ '#FF000080' | colorConvert:'rgba' }}   // rgba(255, 0, 0, 0.5)
  * {{ 'rgba(255, 0, 0, 0.5)' | colorConvert:'hex' }} // #FF000080
- *
- * @author Mofiro Jean
  */
 declare class ColorConvertPipe implements PipeTransform {
     transform(value: string, target: ColorTargetType): string;
@@ -216,32 +471,60 @@ declare class ColorConvertPipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<ColorConvertPipe, "colorConvert", true>;
 }
 
-declare class CountPipe implements PipeTransform {
-    transform(value: any): number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CountPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CountPipe, "count", true>;
+/**
+ * GravatarPipe: Generates Gravatar URLs from email addresses.
+ *
+ * @param {string} value - The email address.
+ * @param {number} [size=80] - The avatar size in pixels.
+ *
+ * @returns {string} - The Gravatar URL.
+ *
+ * @example
+ * <img [src]="'user@example.com' | gravatar:100" />
+ */
+declare class GravatarPipe implements PipeTransform {
+    transform(value: string, size?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GravatarPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GravatarPipe, "gravatar", true>;
 }
 
+interface QrCodeOptions {
+    version?: number;
+    errorCorrectionLevel?: 'low' | 'medium' | 'quartile' | 'high' | 'L' | 'M' | 'Q' | 'H';
+    maskPattern?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    margin?: number;
+    scale?: number;
+    width?: number;
+    color?: {
+        dark?: string;
+        light?: string;
+    };
+    type?: 'image/png' | 'image/jpeg' | 'image/webp';
+    rendererOpts?: {
+        quality?: number;
+    };
+}
 /**
- * CreditCardMaskPipe: Masks all but the last four digits of a string, optionally controlled by a boolean flag.
- * By default, masking is applied.
+ * QrCodePipe: Generates a QR code from a string.
  *
- * @param {string} value - The input string to mask (e.g., credit card number).
- * @param {boolean} shouldMask - (Optional) Determines if masking should be applied. Defaults to true.
- * @returns {string} - The masked string or the original value if `shouldMask` is false or the value is too short.
+ * @param {string} value - The string to encode.
+ * @param {QrCodeOptions} [options] - The QR code options.
  *
- * @example
- * {{ '1234567890123456' | creditCardMask }} // Outputs: **** **** **** 3456
- * {{ '1234-5678-9012-3456' | creditCardMask }} // Outputs: **** **** **** 3456
- * {{ '1234567890123456' | creditCardMask: true }} // Outputs: **** **** **** 3456
- * {{ '1234567890123456' | creditCardMask: false }} // Outputs: 1234567890123456
+ * @returns {Promise<string>} - A promise that resolves with the QR code data URL.
  *
- * @author Mofiro Jean
+ * @example
+ * <img [src]="'Hello, World!' | qrCode | async" />
  */
-declare class CreditCardMaskPipe implements PipeTransform {
-    transform(value: string | null | undefined, shouldMask?: boolean): string | null | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CreditCardMaskPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CreditCardMaskPipe, "creditCardMask", true>;
+declare class QrCodePipe implements PipeTransform {
+    transform(value: string, options?: QrCodeOptions): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QrCodePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<QrCodePipe, "qrCode", true>;
+}
+
+declare class CountPipe implements PipeTransform {
+    transform(value: any): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CountPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CountPipe, "count", true>;
 }
 
 /**
@@ -275,399 +558,497 @@ declare class DeviceTypePipe implements PipeTransform {
 }
 
 /**
- * EmailMaskPipe: Masks the local part of an email address, revealing only the first and last characters.
+ * JsonPrettyPipe: Formats JSON data with indentation and syntax highlighting.
+ *
+ * @param {string | object} value - The JSON string or object to format.
+ * @param {number} [spaces=2] - Number of spaces for indentation.
+ *
+ * @returns {SafeHtml} - Formatted HTML with color-coded JSON.
+ *
+ * @example
+ * {{ '{"name": "John", "age": 30}' | jsonPretty }} // Outputs: Colorful, indented JSON
+ * <pre [innerHTML]="data | jsonPretty:4"></pre> // 4-space indentation
+ */
+declare class JsonPrettyPipe implements PipeTransform {
+    private sanitizer;
+    transform(value: string | object, spaces?: number, highlightProperty?: string | null): SafeHtml;
+    private highlightJson;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonPrettyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<JsonPrettyPipe, "jsonPretty", true>;
+}
+
+/**
+ * TextToSpeechPipe: Converts text to speech using the Web Speech API.
+ *
+ * @param {string} value - The text to convert to speech.
+ * @param {string} [lang='en-US'] - The language (local) for speech synthesis.
+ *
+ * @returns {void} - Triggers speech synthesis (no return value).
+ *
+ * @example
+ * <div>{{ Hello World' | textToSpeech }}</div>
+ * <div>{{ 'Bonjour' | textToSpeech:'fr-FR' }}h</div>
+ */
+declare class TextToSpeechPipe implements PipeTransform {
+    transform(value: string, lang?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextToSpeechPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TextToSpeechPipe, "textToSpeech", true>;
+}
+
+/**
+* TimeAgo: Converts a date into a localized time string.
+ *
+ * Use the in-built Intl.RelativeTimeFormat to convert a date into a localized time string.
+ * It was chosen over moment.js because it's more lightweight and supports more locales.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
+ *
+ * @param {Date | number | string} value - The date to convert.
+ * @param {string} [local='en'] - BCP 47 local code (e.g., 'en', 'fr', 'es').
+ *
+ * @returns {string} - The localized time string.
+ *
+ * @example
+ * {{ date | timeAgo }}       // '5 minutes ago'
+ * {{ date | timeAgo:'fr' }}   // 'il y a 5 minutes'
+ *
+ * @note Pure pipe - output won't automatically update as time passes.
+ * Use signals or periodic change detection to re-trigger.
+* */
+declare class TimeAgoPipePipe implements PipeTransform {
+    private static readonly THRESHOLDS;
+    private cacheLocal;
+    private rtf;
+    transform(value: Date | number | string, local?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimeAgoPipePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TimeAgoPipePipe, "timeAgo", true>;
+}
+
+/**
+ * DiffPipe: Returns elements present in the first array but not in the second.
+ *
+ * Supports primitives and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The source array.
+ * @param {unknown[]} compared - The array to compare against.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {unknown[]} - Elements in value that are not in compared.
+ *
+ * @example
+ * {{ [1, 2, 3, 4, 5] | diff:[3, 4, 5, 6] }}              // [1, 2]
+ * {{ allUsers | diff:activeUsers:'id' }}                    // inactive users
+ * {{ orders | diff:shipped:'meta.trackingId' }}             // unshipped orders
+ */
+declare class DiffPipe implements PipeTransform {
+    transform(value: unknown[], compared: unknown[], key?: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiffPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DiffPipe, "diff", true>;
+}
+
+/**
+ * EveryPipe: Checks if all elements in an array satisfy a condition.
+ *
+ * Supports primitives (equality check) and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to check.
+ * @param {unknown} match - The value to match against.
+ * @param {string} [key] - Optional property path to check (supports dot notation).
+ *
+ * @returns {boolean} - True if all elements match, false otherwise.
+ *
+ * @example
+ * {{ [true, true, true] | every:true }}                     // true
+ * {{ users | every:'active':'status' }}                     // are all users active?
+ * {{ orders | every:'shipped':'meta.state' }}               // are all orders shipped?
+ */
+declare class EveryPipe implements PipeTransform {
+    transform(value: unknown[], match: unknown, key?: string): boolean;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EveryPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EveryPipe, "every", true>;
+}
+
+/**
+ * IntersectionPipe: Returns elements common to both arrays.
  *
- * This Angular pipe transforms an email address string by replacing the characters between the first and last characters of the local part (before the '@') with "***".
- * If the local part is 2 characters or less, it masks all characters except the first.
+ * Supports primitives and objects by property key with dot notation.
  *
- * @param {string} value - The email address string to be masked.
- * @returns {string} - The masked email address, or the original value if it's not a valid email or falsy.
+ * @param {unknown[]} value - The first array.
+ * @param {unknown[]} compared - The second array.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
  *
- * @example
- * {{ 'test@example.com' | emailMask }} // Returns 't***t@example.com'
- * {{ 'te@example.com' | emailMask }} // Returns 't***@example.com'
- * {{ 't@example.com' | emailMask }} // Returns 't***@example.com'
- * {{ 'example.com' | emailMask }} // Returns 'example.com'
- * {{ null | emailMask }} // Returns ''
- * {{ undefined | emailMask }} // Returns ''
+ * @returns {unknown[]} - Elements present in both arrays.
  *
- * @author Mofiro Jean
+ * @example
+ * {{ [1, 2, 3, 4] | intersection:[3, 4, 5, 6] }}              // [3, 4]
+ * {{ teamA | intersection:teamB:'id' }}                         // shared members
+ * {{ required | intersection:granted:'meta.scope' }}            // matched permissions
  */
-declare class EmailMaskPipe implements PipeTransform {
-    transform(value: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EmailMaskPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<EmailMaskPipe, "emailMask", true>;
+declare class IntersectionPipe implements PipeTransform {
+    transform(value: unknown[], compared: unknown[], key?: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IntersectionPipe, "intersection", true>;
 }
 
 /**
- * GravatarPipe: Generates Gravatar URLs from email addresses.
+ * ChunkPipe: Splits an array into smaller arrays of a specified size.
  *
- * @param {string} value - The email address.
- * @param {number} [size=80] - The avatar size in pixels.
+ * @param {unknown[]} value - The array to split.
+ * @param {number} [size=1] - The size of each chunk.
  *
- * @returns {string} - The Gravatar URL.
+ * @returns {unknown[][]} - An array of chunks.
  *
  * @example
- * <img [src]="'user@example.com' | gravatar:100" />
- *
- * @author Mofiro Jean
+ * {{ [1, 2, 3, 4, 5] | chunk:2 }}     // [[1, 2], [3, 4], [5]]
+ * {{ [1, 2, 3, 4, 5, 6] | chunk:3 }}  // [[1, 2, 3], [4, 5, 6]]
  */
-declare class GravatarPipe implements PipeTransform {
-    transform(value: string, size?: number): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<GravatarPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<GravatarPipe, "gravatar", true>;
+declare class ChunkPipe implements PipeTransform {
+    transform(value: unknown[], size?: number): unknown[][];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChunkPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ChunkPipe, "chunk", true>;
 }
 
 /**
- * HighlightPipe: Highlights occurrences of a search term within a string.
+ * FlattenPipe: Flattens nested arrays to a specified depth.
  *
- * This Angular pipe transforms a string input by wrapping all occurrences of a specified
- * search term with a `<span>` element that has the class "highlight".
- * It uses the Angular `DomSanitizer` to bypass security and render the highlighted HTML.
+ * @param {unknown[]} value - The nested array to flatten.
+ * @param {number} [depth=Infinity] - How many levels of nesting to flatten.
  *
- * @param {string} value - The input string in which to highlight the search term.
- * @param {string} searchTerm - The string to search for and highlight.
- * @returns {SafeHtml} - The input string with the search term highlighted, or an empty string if input or searchTerm are falsy.
+ * @returns {unknown[]} - A new flattened array.
  *
  * @example
- * {{ 'This is a test string' | highlight: 'test' }} // Returns 'This is a <span class="highlight">test</span> string'
- * {{ 'This is a test TEST string' | highlight: 'test' }} // Returns 'This is a <span class="highlight">test</span> <span class="highlight">TEST</span> string'
- * {{ 'This is a test string' | highlight: '' }} // Returns 'This is a test string'
- * {{ null | highlight: 'test' }} // Returns ''
- * {{ undefined | highlight: 'test' }} // Returns ''
- *
- * @author Mofiro Jean
+ * {{ [[1, 2], [3, 4]] | flatten }}         // [1, 2, 3, 4]
+ * {{ [[1, [2, [3]]]] | flatten:1 }}        // [1, 2, [3]]
+ * {{ [['a', 'b'], ['c']] | flatten }}      // ['a', 'b', 'c']
  */
-declare class HighlightPipe implements PipeTransform {
-    private sanitizer;
-    transform(value: string, searchTerm: string): SafeHtml;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<HighlightPipe, "highlight", true>;
+declare class Flatten implements PipeTransform {
+    transform(value: unknown[], depth?: number): unknown[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<Flatten, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<Flatten, "flatten", true>;
 }
 
 /**
- * Converts special HTML characters in a string to their corresponding HTML entities.
- * This prevents the browser from interpreting the input as HTML, rendering it as plain text.
+ * GroupByPipe: Groups array elements by a property value.
  *
- * @param {string} value - The input string containing HTML to escape.
- * @returns {string} The string with special HTML characters escaped, or an empty string if input is invalid.
+ * @param {unknown[]} value - The array to group.
+ * @param {string} key - Property path to group by (supports dot notation).
+ *
+ * @returns {Record<string, unknown[]>} - An object where keys are group names and values are arrays.
  *
  * @example
- * ```html
- * {{ '<p>Hello</p>' | htmlEscape }} <!-- Outputs: &lt;p&gt;Hello&lt;/p&gt; -->
- * ```
+ * {{ users | groupBy:'role' }}              // { admin: [...], editor: [...] }
+ * {{ orders | groupBy:'customer.city' }}    // { 'New York': [...], 'London': [...] }
  */
-declare class HtmlEscapePipe implements PipeTransform {
-    transform(value: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlEscapePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<HtmlEscapePipe, "htmlEscape", true>;
+declare class GroupByPipe implements PipeTransform {
+    transform(value: unknown[], key: string): Record<string, unknown[]>;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GroupByPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<GroupByPipe, "groupBy", true>;
 }
 
 /**
- * Sanitizes HTML input to remove unsafe elements while allowing safe HTML to be rendered.
- * Uses Angular's DomSanitizer to mark the output as trusted for use in [innerHTML].
+ * InitialPipe: Returns all elements except the last n.
  *
- * @param {string} value - The input string containing HTML to sanitize.
- * @returns {SafeHtml} The sanitized HTML marked as safe, or an empty string if input is invalid.
+ * @param {unknown[]} value - The array to slice.
+ * @param {number} [n=1] - Number of elements to exclude from the end.
  *
- * @remarks
- * WARNING: Use with caution. Only apply to trusted input to avoid XSS risks.
- * Ensure input is pre-validated or sourced from a secure origin (e.g., a controlled rich-text editor).
+ * @returns {unknown[]} - A new array without the last n elements.
  *
  * @example
- * ```html
- * <div [innerHTML]="'<p>Hello</p><script>alert(1)</script>' | htmlSanitize"></div>
- * <!-- Renders: <p>Hello</p> (script tag removed) -->
- * ```
+ * {{ [1, 2, 3, 4, 5] | initial }}       // [1, 2, 3, 4]
+ * {{ [1, 2, 3, 4, 5] | initial:2 }}     // [1, 2, 3]
+ * {{ ['a', 'b', 'c'] | initial }}        // ['a', 'b']
  */
-declare class HtmlSanitizePipe implements PipeTransform {
-    private sanitizer;
-    transform(value: string): SafeHtml;
-    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlSanitizePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<HtmlSanitizePipe, "htmlSanitize", true>;
+declare class InitialPipe implements PipeTransform {
+    transform(value: unknown, n?: number): unknown[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<InitialPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InitialPipe, "initial", true>;
 }
 
 /**
- * InitialsPipe: Extracts initials from a name.
+ * OrderByPipe: Sorts an array by a property value.
  *
- * @param {string} value - The full name.
+ * @param {unknown[]} value - The array to sort.
+ * @param {string} key - Property path to sort by (supports dot notation).
+ * @param {string} [direction='asc'] - Sort direction: 'asc' or 'desc'.
  *
- * @returns {string} - The initials (e.g., 'John Doe' → 'JD').
+ * @returns {unknown[]} - A new sorted array.
  *
  * @example
- * {{ 'John Doe' | initials }} // Outputs: JD
- * {{ 'Mary Jane Watson' | initials }} // Outputs: MJW
- *
- * @author Mofiro Jean
+ * {{ users | orderBy:'name' }}            // sorted A-Z
+ * {{ users | orderBy:'name':'desc' }}     // sorted Z-A
+ * {{ users | orderBy:'age':'asc' }}       // sorted by age
  */
-declare class InitialsPipe implements PipeTransform {
-    transform(value: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<InitialsPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<InitialsPipe, "initials", true>;
+declare class OrderByPipe implements PipeTransform {
+    transform(value: unknown[], key: string, direction?: 'asc' | 'desc'): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrderByPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<OrderByPipe, "orderBy", true>;
 }
 
 /**
- * IpAddressMaskPipe: Masks the last two octets of an IPv4 address.
+ * PluckPipe: Extracts a property value from every object in an array.
  *
- * @param {string} value - The IPv4 address (e.g., 192.168.1.1).
- * @param {boolean} shouldMask - (Optional) Determines if masking should be applied. Defaults to true..
+ * @param {unknown[]} value - The array of objects.
+ * @param {string} key - Property path to extract (supports dot notation).
  *
- * @returns {string} - The masked IP address (e.g., 192.168.*.*).
+ * @returns {unknown[]} - An array of the extracted values.
  *
  * @example
- * {{ '192.168.1.1' | ipAddressMask }} // Outputs: 192.168.*.*
- * {{ '10.0.0.255' | ipAddressMask }} // Outputs: 10.0.*.*
- *
- * @author Mofiro Jean
+ * {{ users | pluck:'name' }}                // ['Alice', 'Bob', 'Carol']
+ * {{ orders | pluck:'customer.email' }}     // ['a@test.com', 'b@test.com']
  */
-declare class IpAddressMaskPipe implements PipeTransform {
-    transform(value: string, shouldMask?: boolean): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<IpAddressMaskPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<IpAddressMaskPipe, "ipAddressMask", true>;
+declare class PluckPipe implements PipeTransform {
+    transform(value: unknown[], key: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PluckPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PluckPipe, "pluck", true>;
 }
 
 /**
- * JsonPrettyPipe: Formats JSON data with indentation and syntax highlighting.
+ * RangePipe: Generates a numeric sequence array.
  *
- * @param {string | object} value - The JSON string or object to format.
- * @param {number} [spaces=2] - Number of spaces for indentation.
+ * @param {number} value - The number of items to generate (or the end value when start is provided).
+ * @param {number} [start=0] - The starting number.
+ * @param {number} [step=1] - The increment between each number.
  *
- * @returns {SafeHtml} - Formatted HTML with color-coded JSON.
+ * @returns {number[]} - An array of sequential numbers.
  *
  * @example
- * {{ '{"name": "John", "age": 30}' | jsonPretty }} // Outputs: Colorful, indented JSON
- * <pre [innerHTML]="data | jsonPretty:4"></pre> // 4-space indentation
- *
- * @author Mofiro Jean
+ * {{ 5 | range }}            // [0, 1, 2, 3, 4]
+ * {{ 5 | range:1 }}          // [1, 2, 3, 4, 5]
+ * {{ 10 | range:0:2 }}       // [0, 2, 4, 6, 8]
  */
-declare class JsonPrettyPipe implements PipeTransform {
-    private sanitizer;
-    transform(value: string | object, spaces?: number, highlightProperty?: string | null): SafeHtml;
-    private highlightJson;
-    static ɵfac: i0.ɵɵFactoryDeclaration<JsonPrettyPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<JsonPrettyPipe, "jsonPretty", true>;
+declare class RangePipe implements PipeTransform {
+    transform(value: number, start?: number, step?: number): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangePipe, "range", true>;
 }
 
 /**
- * KebabCasePipe: Converts text to kebab-case (e.g., "hello world" → "hello-world").
+ * ReversePipe: Reverses the characters in a string.
  *
- * @param {string} value - The input string to transform.
- * @returns {string} The string in kebab-case, or an empty string if input is invalid.
+ * @param {string} value - The string to reverse.
  *
- * @example
- * ```html
- * {{ 'hello world' | kebabCase }} <!-- Outputs: hello-world -->
- * ```
+ * @returns {string} - The reversed string (e.g., 'hello' → 'olleh').
  *
- * @author Mofiro Jean
+ * @example
+ * {{ 'hello' | reverse }} // Outputs: 'olleh'
+ * {{ '12345' | reverse }} // Outputs: '54321'
+ * <p>{{ userInput | reverse }}</p>
  */
-declare class KebabCasePipe implements PipeTransform {
-    transform(value: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<KebabCasePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<KebabCasePipe, "kebabCase", true>;
+declare class ReversePipe implements PipeTransform {
+    transform(value: string | unknown[]): string | unknown[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReversePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ReversePipe, "reverse", true>;
 }
 
 /**
- * MorseCodePipe: Converts text to Morse code.
+ * SamplePipe: Randomly selects n items from an array.
  *
- * @param {string} value - The text to convert to Morse code.
+ * Uses Fisher-Yates partial shuffle for unbiased selection.
+ * Returns a single item when n=1 (default), or an array when n>1.
  *
- * @returns {string} - The Morse code representation (e.g., 'SOS' → '... --- ...').
+ * @param {unknown[]} value - The array to sample from.
+ * @param {number} [n=1] - Number of items to select.
+ *
+ * @returns {unknown | unknown[]} - A single random item (n=1) or array of random items (n>1).
  *
  * @example
- * {{ 'SOS' | morseCode }} // Outputs: '... --- ...'
- * {{ 'HELP' | morseCode }} // Outputs: '.... . .-.. .--.'
- * <p>{{ userInput | morseCode }}</p>
+ * {{ [1, 2, 3, 4, 5] | sample }}       // 3 (random single)
+ * {{ [1, 2, 3, 4, 5] | sample:3 }}     // [5, 1, 3] (random 3)
+ * {{ users | sample:5 }}               // 5 random users
  *
- * @author Mofiro Jean
+ * @note Impure pipe — returns different results on each change detection cycle.
+ * Bind the result to a signal to control when it re-samples.
  */
-declare class MorseCodePipe implements PipeTransform {
-    private readonly morseCodeMap;
-    transform(value: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MorseCodePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<MorseCodePipe, "morseCode", true>;
+declare class SamplePipe implements PipeTransform {
+    transform(value: unknown[], n?: number): unknown | unknown[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SamplePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SamplePipe, "sample", true>;
 }
 
-interface QrCodeOptions {
-    version?: number;
-    errorCorrectionLevel?: 'low' | 'medium' | 'quartile' | 'high' | 'L' | 'M' | 'Q' | 'H';
-    maskPattern?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7;
-    margin?: number;
-    scale?: number;
-    width?: number;
-    color?: {
-        dark?: string;
-        light?: string;
-    };
-    type?: 'image/png' | 'image/jpeg' | 'image/webp';
-    rendererOpts?: {
-        quality?: number;
-    };
-}
 /**
- * QrCodePipe: Generates a QR code from a string.
+ * ShufflePipe: Randomly reorders elements in an array using the Fisher-Yates
+ algorithm.
  *
- * @param {string} value - The string to encode.
- * @param {QrCodeOptions} [options] - The QR code options.
+ * Uses the Fisher-Yates (Knuth) shuffle for unbiased randomization,
+ * guaranteeing every permutation has equal probability.
  *
- * @returns {Promise<string>} - A promise that resolves with the QR code data URL.
+ * @param {unknown[]} value - The array to shuffle.
+ *
+ * @returns {unknown[]} - A new array with elements in random order.
  *
  * @example
- * <img [src]="'Hello, World!' | qrCode | async" />
+ * {{ [1, 2, 3, 4, 5] | shuffle }}         // [3, 1, 5, 2, 4]
+ * {{ ['a', 'b', 'c'] | shuffle }}          // ['c', 'a', 'b']
  *
- * @author Mofiro Jean
+ * @note Impure pipe — runs on every change detection cycle.
+ * Avoid using in performance-critical templates or bind the result
+ * to a signal/variable to control when it re-shuffles.
  */
-declare class QrCodePipe implements PipeTransform {
-    transform(value: string, options?: QrCodeOptions): Promise<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<QrCodePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<QrCodePipe, "qrCode", true>;
+declare class ShufflePipe implements PipeTransform {
+    transform(value: unknown[]): unknown[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ShufflePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ShufflePipe, "shuffle", true>;
 }
 
 /**
- * ReplacePipe: A custom Angular pipe that either highlights or replaces text based on a pattern.
- *
- * - If `isReplace` is `false`, it highlights occurrences of the pattern (if `highlightClass` is provided).
- * - If `isReplace` is `true`, it replaces occurrences of the pattern with the replacement string, optionally highlighting the replacement.
+ * TailPipe: Returns all elements except the first n.
  *
- * @param {string} value - The input string to transform.
- * @param {string | RegExp} pattern - The pattern to match (string or RegExp). If an empty string, the value is returned as-is.
- * @param {string} replacement - The string to replace matches with.
- * @param {string} [highlightClass] - Optional CSS class for highlighting matched or replaced text (e.g., 'highlight').
- * @param {boolean} [isReplace=true] - Whether to perform replacement (true) or only highlight matches (false).
+ * @param {unknown[]} value - The array to slice.
+ * @param {number} [n=1] - Number of elements to exclude from the start.
  *
- * @returns {string | SafeHtml} - Returns the transformed string or SafeHtml with highlights.
+ * @returns {unknown[]} - A new array without the first n elements.
  *
  * @example
- * {{ 'Hello World' | replace:'World':'Universe' }}
- * // Output: Hello Universe
- *
- * {{ 'test123' | replace:/\d+/g:'X':'highlight' }}
- * // Output: test<span class="highlight">X</span>
+ * {{ [1, 2, 3, 4, 5] | tail }}       // [2, 3, 4, 5]
+ * {{ [1, 2, 3, 4, 5] | tail:2 }}     // [3, 4, 5]
+ * {{ ['a', 'b', 'c'] | tail }}        // ['b', 'c']
+ */
+declare class TailPipe implements PipeTransform {
+    transform(value: unknown[], n?: number): unknown[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<TailPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TailPipe, "tail", true>;
+}
+
+/**
+ * TruthifyPipe: Removes all falsy values from an array.
  *
- * {{ 'Angular is great' | replace:'great':'awesome':'highlight':true }}
- * // Output: Angular is <span class="highlight">awesome</span>
+ * Falsy values: false, 0, -0, '', null, undefined, NaN
  *
- * {{ 'Angular is great' | replace:'great':'awesome':'highlight':false }}
- * // Output: Angular is <span class="highlight">great</span>
+ * @param {unknown[]} value - The array to filter.
  *
- * <div [innerHTML]="'Angular is great' | replace:'great':'awesome':'highlight':false"></div>
- * // Renders: Angular is <span class="highlight">great</span>
+ * @returns {unknown[]} - A new array with only truthy values.
  *
- * @author Mofiro Jean
+ * @example
+ * {{ [0, 1, '', 'hello', null, true] | truthify }}   // [1, 'hello', true]
+ * {{ ['', 'a', '', 'b'] | truthify }}                 // ['a', 'b']
  */
-declare class ReplacePipe implements PipeTransform {
-    private sanitizer;
-    transform(value: string, pattern: string | RegExp, replacement: string, highlightClass?: string, isReplace?: boolean): string | SafeHtml;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ReplacePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<ReplacePipe, "replace", true>;
+declare class TruthifyPipe implements PipeTransform {
+    transform(value: unknown[]): unknown[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<TruthifyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TruthifyPipe, "truthify", true>;
 }
 
 /**
- * ReversePipe: Reverses the characters in a string.
+ * UniquePipe: Removes duplicate values from an array.
  *
- * @param {string} value - The string to reverse.
+ * Supports primitives, objects by property key, and deep nested keys via dot notation.
  *
- * @returns {string} - The reversed string (e.g., 'hello' → 'olleh').
+ * @param {unknown[]} value - The array to deduplicate.
+ * @param {string} [key] - Optional property path to compare objects by (e.g., 'id', 'user.email').
  *
- * @example
- * {{ 'hello' | reverse }} // Outputs: 'olleh'
- * {{ '12345' | reverse }} // Outputs: '54321'
- * <p>{{ userInput | reverse }}</p>
+ * @returns {unknown[]} - A new array with duplicates removed, preserving first occurrence.
  *
- * @author Mofiro Jean
+ * @example
+ * {{ [1, 2, 2, 3] | unique }}                  // [1, 2, 3]
+ * {{ users | unique:'email' }}                  // unique by email
+ * {{ orders | unique:'customer.email' }}        // unique by nested property
  */
-declare class ReversePipe implements PipeTransform {
-    transform(value: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ReversePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<ReversePipe, "reverse", true>;
+declare class UniquePipe implements PipeTransform {
+    transform(value: unknown[], key?: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UniquePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UniquePipe, "unique", true>;
 }
 
 /**
- * SnakeCasePipe: Converts text to snake_case (e.g., "hello world" → "hello_world").
+ * WithoutPipe: Excludes specified elements from an array.
  *
- * @param {string} value - The input string to transform.
- * @returns {string} The string in snake_case, or an empty string if input is invalid.
+ * Supports primitives and objects by property key with dot notation.
  *
- * @example
- * ```html
- * {{ 'hello world' | snakeCase }} <!-- Outputs: hello_world -->
- * ```
+ * @param {unknown[]} value - The array to filter.
+ * @param {unknown[]} excludes - Values to exclude.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
  *
- * @author Mofiro Jean
+ * @returns {unknown[]} - A new array without the excluded elements.
+ *
+ * @example
+ * {{ [1, 2, 3, 4, 5] | without:[2, 4] }}                   // [1, 3, 5]
+ * {{ users | without:['banned']:'status' }}                  // active users
+ * {{ orders | without:['cancelled']:'meta.status' }}         // non-cancelled orders
  */
-declare class SnakeCasePipe implements PipeTransform {
-    transform(value: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SnakeCasePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<SnakeCasePipe, "snakeCase", true>;
+declare class WithoutPipe implements PipeTransform {
+    transform(value: unknown[], excludes: unknown[], key?: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WithoutPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<WithoutPipe, "without", true>;
 }
 
 /**
- * TextToSpeechPipe: Converts text to speech using the Web Speech API.
+ * SomePipe: Checks if at least one element in an array satisfies a condition.
  *
- * @param {string} value - The text to convert to speech.
- * @param {string} [lang='en-US'] - The language (local) for speech synthesis.
+ * Supports primitives (equality check) and objects by property key with dot notation.
  *
- * @returns {void} - Triggers speech synthesis (no return value).
+ * @param {unknown[]} value - The array to check.
+ * @param {unknown} match - The value to match against.
+ * @param {string} [key] - Optional property path to check (supports dot notation).
  *
- * @example
- * <div>{{ Hello World' | textToSpeech }}</div>
- * <div>{{ 'Bonjour' | textToSpeech:'fr-FR' }}h</div>
+ * @returns {boolean} - True if at least one element matches, false otherwise.
  *
- * @author Mofiro Jean
+ * @example
+ * {{ [false, false, true] | some:true }}                    // true
+ * {{ users | some:'admin':'role' }}                          // any admins?
+ * {{ orders | some:'failed':'meta.status' }}                 // any failures?
  */
-declare class TextToSpeechPipe implements PipeTransform {
-    transform(value: string, lang?: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TextToSpeechPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<TextToSpeechPipe, "textToSpeech", true>;
+declare class SomePipe implements PipeTransform {
+    transform(value: unknown[], match: unknown, key?: string): boolean;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SomePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SomePipe, "some", true>;
 }
 
 /**
- * TitleCasePipe: Capitalizes the first letter of each word in a string.
+ * UnionPipe: Combines two arrays, keeping only unique elements.
  *
- * @param {string} value - The input string to transform.
- * @returns {string} The string with each word capitalized, or an empty string if input is invalid.
+ * Supports primitives and objects by property key with dot notation.
+ *
+ * @param {unknown[]} value - The first array.
+ * @param {unknown[]} other - The second array.
+ * @param {string} [key] - Optional property path for uniqueness check (supports dot notation).
+ *
+ * @returns {unknown[]} - A merged array with duplicates removed.
  *
  * @example
- * ```html
- * {{ 'hello world' | titleCase }} <!-- Outputs: Hello World -->
- * ```
+ * {{ [1, 2, 3] | union:[3, 4, 5] }}                        // [1, 2, 3, 4, 5]
+ * {{ admins | union:editors:'id' }}                          // all unique users
+ * {{ local | union:remote:'meta.uuid' }}                     // merged records
  */
-declare class TitleCasePipe implements PipeTransform {
-    transform(value: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TitleCasePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<TitleCasePipe, "titleCase", true>;
+declare class UnionPipe implements PipeTransform {
+    transform(value: unknown[], other: unknown[], key?: string): unknown[];
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UnionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UnionPipe, "union", true>;
 }
 
 /**
- * TruncatePipe: Truncates a string to a specified maximum length, optionally preserving words.
+ * FilterByPipe: Filters an array by matching a search term against object
+ properties.
  *
- * This Angular pipe transforms a string input by truncating it to the given `maxLength`.
- * It provides options to customize the ellipsis and preserve word boundaries.
+ * @param {unknown[]} value - The array to filter.
+ * @param {string} search - The search term.
+ * @param {string} [key] - Property to search in. If omitted, searches all string
+ properties.
  *
- * @param {string} value - The input string to be truncated.
- * @param {number} [maxLength=10] - The maximum length of the truncated string. Defaults to 10.
- * @param {string} [ellipsis='...'] - The string to append to the truncated portion. Defaults to '...'.
- * @param {boolean} [preserveWords=false] - If true, truncates at the last space before `maxLength` to avoid cutting words. Defaults to false.
- * @returns {string} - The truncated string. Returns an empty string if the input is null, undefined, or not a string.
+ * @returns {unknown[]} - Filtered array with matching items.
  *
  * @example
- * {{ 'This is a long sentence' | truncate }} // Returns 'This is a...'
- * {{ 'This is a long sentence' | truncate: 20 }} // Returns 'This is a long sente...'
- * {{ 'This is a long sentence' | truncate: 15: ' [more]' }} // Returns 'This is a long [more]'
- * {{ 'This is a long sentence' | truncate: 15: '...' : true }} // Returns 'This is a...'
- * {{ 'This is a long sentence' | truncate: 20: '...' : true }} // Returns 'This is a long...'
- * {{ null | truncate }} // Returns ''
- * {{ undefined | truncate }} // Returns ''
- *
- * @author Mofiro Jean
+ * {{ users | filterBy:'alice':'name' }}     // users with 'alice' in name
+ * {{ users | filterBy:'admin':'role' }}     // users with role 'admin'
+ * {{ users | filterBy:'bob' }}              // search all properties for 'bob'
  */
-declare class TruncatePipe implements PipeTransform {
-    transform(value: string, maxLength?: number, ellipsis?: string, preserveWords?: boolean): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TruncatePipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<TruncatePipe, "truncate", true>;
+declare class FilterByPipe implements PipeTransform {
+    transform(value: unknown[], search: string, key?: string): unknown[];
+    private searchObject;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterByPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterByPipe, "filterBy", true>;
 }
 
 declare const ALL_PIPES: Provider[];
 
-export { ALL_PIPES, AsciiArtPipe, BarcodePipe, CamelCasePipe, ColorConvertPipe, CountPipe, CreditCardMaskPipe, DeviceTypePipe, EmailMaskPipe, GravatarPipe, HighlightPipe, HtmlEscapePipe, HtmlSanitizePipe, InitialsPipe, IpAddressMaskPipe, JsonPrettyPipe, KebabCasePipe, MorseCodePipe, QrCodePipe, ReplacePipe, ReversePipe, SnakeCasePipe, TextToSpeechPipe, TitleCasePipe, TruncatePipe };
+export { ALL_PIPES, AsciiArtPipe, BarcodePipe, CamelCasePipe, ChunkPipe, ColorConvertPipe, CountPipe, CreditCardMaskPipe, DeviceTypePipe, DiffPipe, EmailMaskPipe, EveryPipe, FilterByPipe, Flatten, GravatarPipe, GroupByPipe, HighlightPipe, HtmlEscapePipe, HtmlSanitizePipe, InitialPipe, InitialsPipe, IntersectionPipe, IpAddressMaskPipe, JsonPrettyPipe, KebabCasePipe, MorseCodePipe, OrderByPipe, PluckPipe, QrCodePipe, RangePipe, ReplacePipe, ReversePipe, SamplePipe, ShufflePipe, SnakeCasePipe, SomePipe, TailPipe, TextToSpeechPipe, TimeAgoPipePipe, TitleCasePipe, TruncatePipe, TruthifyPipe, UnionPipe, UniquePipe, WithoutPipe };
 export type { AsciiArtOptions, BarcodeElementType, BarcodeFormat, BarcodeOptions, ColorTargetType, DeviceType, QrCodeOptions };