ngx-transforms 0.2.0 → 0.3.1

package/types/ngx-transforms.d.ts

@@ -262,6 +262,822 @@ declare class TruncatePipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<TruncatePipe, "truncate", true>;
 }
 
+/**
+ * TrimPipe: Removes whitespace (or specified characters) from both ends of a string.
+ *
+ * By default, trims whitespace. Pass a string of characters to trim those instead.
+ *
+ * @param {string} value - The string to trim.
+ * @param {string} [chars] - Optional set of characters to trim from both ends.
+ *
+ * @returns {string} - The trimmed string, or an empty string if input is invalid.
+ *
+ * @example
+ * {{ '  hello  ' | trim }}                                   // 'hello'
+ * {{ '--hello--' | trim:'-' }}                               // 'hello'
+ * {{ '***title***' | trim:'*' }}                             // 'title'
+ */
+declare class TrimPipe implements PipeTransform {
+    transform(value: string, chars?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrimPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TrimPipe, "trim", true>;
+}
+
+/**
+ * CapitalizePipe: Uppercases the first character and lowercases the rest.
+ *
+ * Useful for normalizing headings, labels, and proper nouns.
+ * Differs from `upperFirst` which only uppercases the first character without
+ * altering the remaining characters.
+ *
+ * @param {string} value - The string to capitalize.
+ *
+ * @returns {string} - The capitalized string, or an empty string if input is invalid.
+ *
+ * @example
+ * {{ 'hello world' | capitalize }}                           // 'Hello world'
+ * {{ 'HELLO WORLD' | capitalize }}                           // 'Hello world'
+ * {{ 'hELLo' | capitalize }}                                 // 'Hello'
+ */
+declare class CapitalizePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CapitalizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CapitalizePipe, "capitalize", true>;
+}
+
+/**
+ * UpperFirstPipe: Uppercases the first character of a string without altering the rest.
+ *
+ * Differs from `capitalize` which also lowercases the remaining characters.
+ * Useful when you want to preserve acronyms, camelCase, or existing casing.
+ *
+ * @param {string} value - The string to transform.
+ *
+ * @returns {string} - The transformed string, or an empty string if input is invalid.
+ *
+ * @example
+ * {{ 'hello WORLD' | upperFirst }}                           // 'Hello WORLD'
+ * {{ 'javaScript' | upperFirst }}                            // 'JavaScript'
+ * {{ 'apiKey' | upperFirst }}                                // 'ApiKey'
+ */
+declare class UpperFirstPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UpperFirstPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<UpperFirstPipe, "upperFirst", true>;
+}
+
+/**
+ * LeftPadPipe: Pads a string on the left until it reaches the target length.
+ *
+ * Wraps JavaScript's native `padStart`. If the input is already at or above
+ * the target length, returns it unchanged. Defaults to padding with spaces.
+ *
+ * @param {string | number} value - The string or number to pad.
+ * @param {number} length - The target length of the resulting string.
+ * @param {string} [char=' '] - The character (or string) to pad with.
+ *
+ * @returns {string} - The padded string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ '5' | leftPad:3:'0' }}                                  // '005'
+ * {{ 42 | leftPad:5 }}                                       // '   42'
+ * {{ 'hi' | leftPad:6:'-' }}                                 // '----hi'
+ */
+declare class LeftPadPipe implements PipeTransform {
+    transform(value: string | number, length: number, char?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LeftPadPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LeftPadPipe, "leftPad", true>;
+}
+
+/**
+ * RightPadPipe: Pads a string on the right until it reaches the target length.
+ *
+ * Wraps JavaScript's native `padEnd`. If the input is already at or above
+ * the target length, returns it unchanged. Defaults to padding with spaces.
+ *
+ * @param {string | number} value - The string or number to pad.
+ * @param {number} length - The target length of the resulting string.
+ * @param {string} [char=' '] - The character (or string) to pad with.
+ *
+ * @returns {string} - The padded string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'hi' | rightPad:5:'.' }}                                // 'hi...'
+ * {{ 'name' | rightPad:10 }}                                 // 'name      '
+ * {{ 42 | rightPad:5:'0' }}                                  // '42000'
+ */
+declare class RightPadPipe implements PipeTransform {
+    transform(value: string | number, length: number, char?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RightPadPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RightPadPipe, "rightPad", true>;
+}
+
+/**
+ * PadPipe: Pads a string on both sides to reach the target length (centers it).
+ *
+ * When the padding is uneven, the extra character goes to the right.
+ * Defaults to padding with spaces.
+ *
+ * @param {string | number} value - The string or number to pad.
+ * @param {number} length - The target length of the resulting string.
+ * @param {string} [char=' '] - The character (or string) to pad with.
+ *
+ * @returns {string} - The padded string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'x' | pad:5:'-' }}                                      // '--x--'
+ * {{ 'hi' | pad:6:'*' }}                                     // '**hi**'
+ * {{ 'hi' | pad:7:'*' }}                                     // '**hi***' (extra right)
+ */
+declare class PadPipe implements PipeTransform {
+    transform(value: string | number, length: number, char?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PadPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PadPipe, "pad", true>;
+}
+
+/**
+ * RepeatPipe: Repeats a string a given number of times.
+ *
+ * Wraps `String.prototype.repeat`. Optional separator is inserted between repetitions.
+ *
+ * @param {string} value - The string to repeat.
+ * @param {number} count - Number of times to repeat (must be >= 0).
+ * @param {string} [separator=''] - Optional separator placed between repetitions.
+ *
+ * @returns {string} - The repeated string, or an empty string if input is invalid.
+ *
+ * @example
+ * {{ '-' | repeat:10 }}                                      // '----------'
+ * {{ 'ha' | repeat:3 }}                                      // 'hahaha'
+ * {{ 'item' | repeat:3:', ' }}                               // 'item, item, item'
+ */
+declare class RepeatPipe implements PipeTransform {
+    transform(value: string, count: number, separator?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RepeatPipe, "repeat", true>;
+}
+
+/**
+ * SlugifyPipe: Converts a string into a URL-friendly slug.
+ *
+ * Removes diacritics, lowercases, replaces non-alphanumerics with the separator,
+ * collapses consecutive separators, and trims them from the ends.
+ *
+ * @param {string} value - The string to slugify.
+ * @param {string} [separator='-'] - Character used to join words.
+ *
+ * @returns {string} - The slugified string, or an empty string if input is invalid.
+ *
+ * @example
+ * {{ 'Hello World!' | slugify }}                             // 'hello-world'
+ * {{ 'Café & Tea' | slugify }}                               // 'cafe-tea'
+ * {{ 'My Blog Post' | slugify:'_' }}                         // 'my_blog_post'
+ */
+declare class SlugifyPipe implements PipeTransform {
+    transform(value: string, separator?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlugifyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SlugifyPipe, "slugify", true>;
+}
+
+/**
+ * StripTagsPipe: Removes HTML tags from a string.
+ *
+ * By default strips every tag. Pass an array of allowed tag names to keep
+ * those specific tags while stripping the rest. HTML comments and DOCTYPEs
+ * are always removed.
+ *
+ * Note: this pipe returns a plain string — the caller is responsible for
+ * binding the output safely (e.g. via `[textContent]`). For sanitization
+ * that also neutralizes dangerous attributes/scripts, use HtmlSanitizePipe.
+ *
+ * @param {string} value - The HTML string to strip.
+ * @param {string[]} [allowedTags] - Optional list of tag names to preserve.
+ *
+ * @returns {string} - The stripped string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ '<p>Hi <b>there</b></p>' | stripTags }}                  // 'Hi there'
+ * {{ '<p>Hi <b>bold</b></p>' | stripTags:['b'] }}             // 'Hi <b>bold</b>'
+ * {{ '<script>alert(1)</script>Safe' | stripTags }}           // 'Safe'
+ */
+declare class StripTagsPipe implements PipeTransform {
+    transform(value: string, allowedTags?: string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StripTagsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<StripTagsPipe, "stripTags", true>;
+}
+
+/**
+ * EncodeUriPipe: Encodes a full URI by escaping characters that would be invalid.
+ *
+ * Wraps the native `encodeURI`. Preserves URI structural characters
+ * (`: / ? # [ ] @ ! $ & ' ( ) * + , ; =`) so this is suitable for entire URLs,
+ * not for individual query string values (use `encodeURIComponent` for those).
+ *
+ * @param {string} value - The URI to encode.
+ *
+ * @returns {string} - The encoded URI, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'https://example.com/?q=hi world' | encodeURI }}        // 'https://example.com/?q=hi%20world'
+ * {{ '/path with space.html' | encodeURI }}                  // '/path%20with%20space.html'
+ */
+declare class EncodeUriPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EncodeUriPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EncodeUriPipe, "encodeURI", true>;
+}
+
+/**
+ * EncodeUriComponentPipe: Encodes a single URI component, escaping reserved characters.
+ *
+ * Wraps the native `encodeURIComponent`. Encodes everything except
+ * `A-Z a-z 0-9 - _ . ! ~ * ' ( )`. Use this for query parameter values,
+ * path segments, or anywhere a value must not collide with URL syntax.
+ *
+ * @param {string} value - The URI component to encode.
+ *
+ * @returns {string} - The encoded component, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'hi world&you' | encodeURIComponent }}                  // 'hi%20world%26you'
+ * {{ 'foo/bar?baz=1' | encodeURIComponent }}                 // 'foo%2Fbar%3Fbaz%3D1'
+ */
+declare class EncodeUriComponentPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EncodeUriComponentPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<EncodeUriComponentPipe, "encodeURIComponent", true>;
+}
+
+/**
+ * DecodeUriPipe: Decodes a URI previously encoded with `encodeURI`.
+ *
+ * Wraps the native `decodeURI`. Returns the input unchanged if the string
+ * contains a malformed escape sequence.
+ *
+ * @param {string} value - The encoded URI to decode.
+ *
+ * @returns {string} - The decoded URI, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'https://example.com/?q=hi%20world' | decodeURI }}      // 'https://example.com/?q=hi world'
+ * {{ '/path%20with%20space.html' | decodeURI }}              // '/path with space.html'
+ */
+declare class DecodeUriPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DecodeUriPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DecodeUriPipe, "decodeURI", true>;
+}
+
+/**
+ * DecodeUriComponentPipe: Decodes a URI component encoded with `encodeURIComponent`.
+ *
+ * Wraps the native `decodeURIComponent`. Returns the input unchanged if the
+ * string contains a malformed escape sequence.
+ *
+ * @param {string} value - The encoded URI component to decode.
+ *
+ * @returns {string} - The decoded component, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'hi%20world%26you' | decodeURIComponent }}              // 'hi world&you'
+ * {{ 'foo%2Fbar%3Fbaz%3D1' | decodeURIComponent }}           // 'foo/bar?baz=1'
+ */
+declare class DecodeUriComponentPipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DecodeUriComponentPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DecodeUriComponentPipe, "decodeURIComponent", true>;
+}
+
+/**
+ * SplitPipe: Splits a string into an array using the given separator.
+ *
+ * Wraps `String.prototype.split`. Returns an empty array for invalid inputs.
+ *
+ * @param {string} value - The string to split.
+ * @param {string | RegExp} [separator=''] - Character, string, or regex to split on.
+ *   An empty separator splits the string into individual characters.
+ * @param {number} [limit] - Optional maximum number of elements to return.
+ *
+ * @returns {string[]} - The resulting array, or an empty array for invalid input.
+ *
+ * @example
+ * {{ 'a,b,c' | split:',' }}                                  // ['a', 'b', 'c']
+ * {{ 'abc' | split }}                                        // ['a', 'b', 'c']
+ * {{ 'one two three' | split:' ':2 }}                        // ['one', 'two']
+ */
+declare class SplitPipe implements PipeTransform {
+    transform(value: string, separator?: string | RegExp, limit?: number): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<SplitPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SplitPipe, "split", true>;
+}
+
+/**
+ * MatchPipe: Returns all regex matches found in a string.
+ *
+ * Wraps `String.prototype.match` with a global default. Returns an empty array
+ * when nothing matches or the regex is invalid.
+ *
+ * @param {string} value - The string to search.
+ * @param {string | RegExp} pattern - Pattern string (or RegExp) to match.
+ * @param {string} [flags='g'] - Regex flags used when `pattern` is a string.
+ *
+ * @returns {string[]} - Array of matches, or empty array if none / invalid input.
+ *
+ * @example
+ * {{ 'abc123def456' | match:'[0-9]+' }}                      // ['123', '456']
+ * {{ 'hello world' | match:'[a-z]+' }}                       // ['hello', 'world']
+ * {{ 'HELLO' | match:'[a-z]+':'gi' }}                        // ['HELLO']
+ */
+declare class MatchPipe implements PipeTransform {
+    transform(value: string, pattern: string | RegExp, flags?: string): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatchPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MatchPipe, "match", true>;
+}
+
+/**
+ * TestPipe: Returns true when a string matches a regex pattern.
+ *
+ * Wraps `RegExp.prototype.test`. Returns false for invalid input or regex.
+ *
+ * @param {string} value - The string to test.
+ * @param {string | RegExp} pattern - Pattern string (or RegExp) to test against.
+ * @param {string} [flags=''] - Regex flags used when `pattern` is a string.
+ *
+ * @returns {boolean} - `true` if the pattern matches anywhere in the string.
+ *
+ * @example
+ * {{ 'abc@x.com' | test:'@' }}                               // true
+ * {{ 'ABC' | test:'[a-z]':'i' }}                             // true
+ * {{ '123' | test:'^[0-9]+$' }}                              // true
+ */
+declare class TestPipe implements PipeTransform {
+    transform(value: string, pattern: string | RegExp, flags?: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TestPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TestPipe, "test", true>;
+}
+
+/**
+ * NewlinesPipe: Replaces line breaks in a string with a custom replacement.
+ *
+ * Handles all common line-break variants (`\n`, `\r\n`, `\r`). Defaults to
+ * `<br>` for HTML display via `[innerHTML]`. Pass any string to customize.
+ *
+ * @param {string} value - The string containing line breaks.
+ * @param {string} [replacement='<br>'] - String inserted in place of each line break.
+ *
+ * @returns {string} - The transformed string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ text | newlines }}                                      // 'a<br>b<br>c' (use [innerHTML])
+ * {{ text | newlines:' | ' }}                                // 'a | b | c'
+ * {{ text | newlines:' ' }}                                  // 'a b c' (flatten to single line)
+ */
+declare class NewlinesPipe implements PipeTransform {
+    transform(value: string, replacement?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NewlinesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NewlinesPipe, "newlines", true>;
+}
+
+/**
+ * TemplatePipe: Replaces `{key}` placeholders in a string with values from an object.
+ *
+ * Supports dot notation for nested keys. Missing keys are left as-is.
+ *
+ * @param {string} value - The template string containing placeholders like `{name}`.
+ * @param {Record<string, unknown>} [values={}] - Map of keys to replacement values.
+ *
+ * @returns {string} - The interpolated string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'Hello {name}!' | template:{name:'Alice'} }}            // 'Hello Alice!'
+ * {{ '{user.name} is {user.age}' | template:{user:{name:'Bob',age:30}} }}  // 'Bob is 30'
+ * {{ 'Hi {missing}!' | template:{name:'Alice'} }}            // 'Hi {missing}!'
+ */
+declare class TemplatePipe implements PipeTransform {
+    transform(value: string, values?: Record<string, unknown>): string;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TemplatePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<TemplatePipe, "template", true>;
+}
+
+/**
+ * LatinizePipe: Strips diacritics (accents) from a string while preserving
+ * casing, spaces, and punctuation.
+ *
+ * Uses Unicode NFD normalization to split combining marks from base letters,
+ * then removes the combining mark range (U+0300–U+036F). Unlike `slugify`,
+ * this pipe leaves the string structure intact — it only removes accents.
+ *
+ * @param {string} value - The string to latinize.
+ *
+ * @returns {string} - The latinized string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'Café' | latinize }}                                    // 'Cafe'
+ * {{ 'naïve résumé' | latinize }}                            // 'naive resume'
+ * {{ 'Crème Brûlée' | latinize }}                            // 'Creme Brulee'
+ */
+declare class LatinizePipe implements PipeTransform {
+    transform(value: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LatinizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LatinizePipe, "latinize", true>;
+}
+
+/**
+ * WrapPipe: Surrounds a string with a prefix and optional suffix.
+ *
+ * When no suffix is provided, the prefix is used on both sides.
+ *
+ * @param {string} value - The string to wrap.
+ * @param {string} [prefix=''] - Text to place before the value.
+ * @param {string} [suffix] - Text to place after the value (defaults to prefix).
+ *
+ * @returns {string} - The wrapped string, or empty string if input is invalid.
+ *
+ * @example
+ * {{ 'value' | wrap:'[':']' }}                               // '[value]'
+ * {{ 'bold' | wrap:'**' }}                                   // '**bold**'
+ * {{ 'tag' | wrap:'<':'>' }}                                 // '<tag>'
+ */
+declare class WrapPipe implements PipeTransform {
+    transform(value: string, prefix?: string, suffix?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrapPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<WrapPipe, "wrap", true>;
+}
+
+/**
+ * KeysPipe: Returns the own enumerable property names of an object as an array.
+ *
+ * Wraps `Object.keys`. Works on plain objects and arrays. Returns an empty array
+ * for null, undefined, or primitive inputs.
+ *
+ * @param {unknown} value - The object whose keys to extract.
+ *
+ * @returns {string[]} - Array of property names, or an empty array if invalid input.
+ *
+ * @example
+ * {{ { a: 1, b: 2, c: 3 } | keys }}                          // ['a', 'b', 'c']
+ * {{ user | keys }}                                          // ['name', 'age', 'email']
+ * @for (key of obj | keys; track key) { ... }
+ */
+declare class KeysPipe implements PipeTransform {
+    transform(value: unknown): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeysPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<KeysPipe, "keys", true>;
+}
+
+/**
+ * ValuesPipe: Returns the own enumerable property values of an object as an array.
+ *
+ * Wraps `Object.values`. Works on plain objects and arrays. Returns an empty array
+ * for null, undefined, or primitive inputs.
+ *
+ * @param {unknown} value - The object whose values to extract.
+ *
+ * @returns {unknown[]} - Array of property values, or an empty array if invalid input.
+ *
+ * @example
+ * {{ { a: 1, b: 2, c: 3 } | values }}                        // [1, 2, 3]
+ * {{ user | values }}                                        // ['Alice', 30, 'a@b.com']
+ * @for (val of obj | values; track $index) { ... }
+ */
+declare class ValuesPipe implements PipeTransform {
+    transform(value: unknown): unknown[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValuesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ValuesPipe, "values", true>;
+}
+
+/**
+ * PairsPipe: Returns the own enumerable properties of an object as an array of
+ * [key, value] tuples.
+ *
+ * Wraps `Object.entries`. Works on plain objects and arrays. Returns an empty
+ * array for null, undefined, or primitive inputs.
+ *
+ * @param {unknown} value - The object to convert into key/value pairs.
+ *
+ * @returns {[string, unknown][]} - Array of [key, value] tuples, or empty array.
+ *
+ * @example
+ * {{ { a: 1, b: 2 } | pairs }}                               // [['a', 1], ['b', 2]]
+ * @for (entry of user | pairs; track entry[0]) {
+ *   <li>{{ entry[0] }}: {{ entry[1] }}</li>
+ * }
+ */
+declare class PairsPipe implements PipeTransform {
+    transform(value: unknown): [string, unknown][];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PairsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PairsPipe, "pairs", true>;
+}
+
+/**
+ * PickPipe: Returns a new object containing only the specified keys.
+ *
+ * Non-existent keys are skipped silently. Returns an empty object for null,
+ * undefined, or primitive inputs. Does not mutate the input.
+ *
+ * @param {unknown} value - The source object.
+ * @param {string[] | string} keys - Key (or array of keys) to keep.
+ *
+ * @returns {Record<string, unknown>} - A new object with only the picked keys.
+ *
+ * @example
+ * {{ user | pick:['name', 'email'] }}                        // { name: 'Alice', email: 'a@b.com' }
+ * {{ obj | pick:'id' }}                                      // { id: 42 }
+ */
+declare class PickPipe implements PipeTransform {
+    transform(value: unknown, keys: string[] | string): Record<string, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PickPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PickPipe, "pick", true>;
+}
+
+/**
+ * OmitPipe: Returns a new object with the specified keys removed.
+ *
+ * Keys that don't exist on the source are ignored. Returns an empty object
+ * for null, undefined, or primitive inputs. Does not mutate the input.
+ *
+ * @param {unknown} value - The source object.
+ * @param {string[] | string} keys - Key (or array of keys) to remove.
+ *
+ * @returns {Record<string, unknown>} - A new object without the omitted keys.
+ *
+ * @example
+ * {{ user | omit:['password'] }}                             // user without password
+ * {{ obj | omit:['internal', '_id'] }}                       // public-safe view
+ */
+declare class OmitPipe implements PipeTransform {
+    transform(value: unknown, keys: string[] | string): Record<string, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OmitPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<OmitPipe, "omit", true>;
+}
+
+/**
+ * InvertPipe: Returns a new object with keys and values swapped.
+ *
+ * Values are coerced to strings to become valid keys. When two source keys
+ * share a value, the **last one wins** (use `invertBy` if you need to keep
+ * every collision as an array). Returns an empty object for null, undefined,
+ * or primitive inputs. Does not mutate the input.
+ *
+ * @param {unknown} value - The source object.
+ *
+ * @returns {Record<string, string>} - A new object with keys/values swapped.
+ *
+ * @example
+ * {{ { a: 1, b: 2 } | invert }}                              // { '1': 'a', '2': 'b' }
+ * {{ { en: 'hello', fr: 'bonjour' } | invert }}              // { hello: 'en', bonjour: 'fr' }
+ * {{ { a: 1, b: 1 } | invert }}                              // { '1': 'b' } (last wins)
+ */
+declare class InvertPipe implements PipeTransform {
+    transform(value: unknown): Record<string, string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InvertPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InvertPipe, "invert", true>;
+}
+
+/**
+ * InvertByPipe: Returns a new object with values as keys, grouping the original
+ * keys for each value into an array.
+ *
+ * Unlike `invert`, no data is lost when multiple source keys share a value —
+ * they're collected into an array under the shared key.
+ *
+ * @param {unknown} value - The source object.
+ *
+ * @returns {Record<string, string[]>} - A new object with values-as-keys
+ *   pointing at arrays of the original keys.
+ *
+ * @example
+ * {{ { a: 1, b: 2, c: 1 } | invertBy }}                      // { '1': ['a', 'c'], '2': ['b'] }
+ * {{ { alice: 'admin', bob: 'user', carol: 'admin' } | invertBy }}
+ *   // { admin: ['alice', 'carol'], user: ['bob'] }
+ */
+declare class InvertByPipe implements PipeTransform {
+    transform(value: unknown): Record<string, string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InvertByPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InvertByPipe, "invertBy", true>;
+}
+
+/**
+ * DiffObjPipe: Returns the slice of `value` whose properties differ from `compareTo`.
+ *
+ * For each key in `value`, the entry is included in the result when:
+ * - The key is missing from `compareTo`, or
+ * - `value[key]` is not strictly equal (`!==`) to `compareTo[key]`.
+ *
+ * Comparison is shallow — nested objects/arrays are compared by reference.
+ *
+ * @param {unknown} value - The source object.
+ * @param {unknown} compareTo - The object to compare against.
+ *
+ * @returns {Record<string, unknown>} - A new object containing the differing entries.
+ *
+ * @example
+ * {{ { a: 1, b: 2 } | diffObj:{ a: 1, b: 99 } }}              // { b: 2 }
+ * {{ { a: 1, b: 2, c: 3 } | diffObj:{ a: 1 } }}               // { b: 2, c: 3 }
+ * {{ { a: 1 } | diffObj:{ a: 1 } }}                           // {} (no differences)
+ */
+declare class DiffObjPipe implements PipeTransform {
+    transform(value: unknown, compareTo: unknown): Record<string, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiffObjPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DiffObjPipe, "diffObj", true>;
+}
+
+/**
+ * IsDefinedPipe: Returns `true` when the value is neither `null` nor `undefined`.
+ *
+ * Useful for guarding optional bindings in templates without resorting to
+ * verbose `value !== null && value !== undefined` checks. Empty strings,
+ * `0`, and `false` are all considered defined.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if defined, `false` if null/undefined.
+ *
+ * @example
+ * {{ user | isDefined }}      // true when user is set
+ * {{ 0 | isDefined }}         // true
+ * {{ '' | isDefined }}        // true
+ * {{ null | isDefined }}      // false
+ * {{ undefined | isDefined }} // false
+ */
+declare class IsDefinedPipe implements PipeTransform {
+    transform(value: unknown): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsDefinedPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsDefinedPipe, "isDefined", true>;
+}
+
+/**
+ * IsNullPipe: Returns `true` only when the value is exactly `null`.
+ *
+ * Strict check — `undefined` returns `false`. Use `isDefined` (with `!`) if
+ * you want to catch both null and undefined together.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is null, `false` otherwise.
+ *
+ * @example
+ * {{ null | isNull }}      // true
+ * {{ undefined | isNull }} // false
+ * {{ 0 | isNull }}         // false
+ * {{ '' | isNull }}        // false
+ */
+declare class IsNullPipe implements PipeTransform {
+    transform(value: unknown): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsNullPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsNullPipe, "isNull", true>;
+}
+
+/**
+ * IsStringPipe: Returns `true` when the value is a primitive string.
+ *
+ * Uses `typeof value === 'string'` — boxed `String` objects (rare) are not
+ * matched. Useful for polymorphic templates that render values from JSON,
+ * dynamic forms, or `unknown`-typed data.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is a string primitive, `false` otherwise.
+ *
+ * @example
+ * {{ 'hello' | isString }}  // true
+ * {{ '' | isString }}       // true
+ * {{ 42 | isString }}       // false
+ * {{ null | isString }}     // false
+ */
+declare class IsStringPipe implements PipeTransform {
+    transform(value: unknown): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsStringPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsStringPipe, "isString", true>;
+}
+
+/**
+ * IsNumberPipe: Returns `true` when the value is a primitive number.
+ *
+ * Uses `typeof value === 'number'`. By design `NaN` returns `true` because
+ * its type is `number` — if you need a finite-only check, follow up with
+ * `Number.isFinite`. Numeric strings (e.g. `'42'`) return `false`.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is a number primitive, `false` otherwise.
+ *
+ * @example
+ * {{ 42 | isNumber }}      // true
+ * {{ 0 | isNumber }}       // true
+ * {{ NaN | isNumber }}     // true
+ * {{ '42' | isNumber }}    // false
+ * {{ null | isNumber }}    // false
+ */
+declare class IsNumberPipe implements PipeTransform {
+    transform(value: unknown): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsNumberPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsNumberPipe, "isNumber", true>;
+}
+
+/**
+ * IsArrayPipe: Returns `true` when the value is an Array.
+ *
+ * Backed by `Array.isArray`, so array-likes (NodeList, HTMLCollection,
+ * arguments, typed arrays) all return `false`. Use it to discriminate between
+ * structural and scalar inputs in polymorphic templates.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is an array, `false` otherwise.
+ *
+ * @example
+ * {{ [1, 2, 3] | isArray }}     // true
+ * {{ [] | isArray }}            // true
+ * {{ 'abc' | isArray }}         // false
+ * {{ { length: 0 } | isArray }} // false
+ */
+declare class IsArrayPipe implements PipeTransform {
+    transform(value: unknown): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsArrayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsArrayPipe, "isArray", true>;
+}
+
+/**
+ * IsObjectPipe: Returns `true` when the value is a non-null object that is
+ * not an array.
+ *
+ * Lenient — class instances, Date, Map, Set, and RegExp all return `true`
+ * because their JS type is "object". Only `null` and arrays are excluded.
+ * Pair with `isArray` to discriminate between the two structural shapes.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is a non-null, non-array object.
+ *
+ * @example
+ * {{ { a: 1 } | isObject }} // true
+ * {{ {} | isObject }}       // true
+ * {{ [1, 2] | isObject }}   // false
+ * {{ null | isObject }}     // false
+ * {{ 'abc' | isObject }}    // false
+ */
+declare class IsObjectPipe implements PipeTransform {
+    transform(value: unknown): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsObjectPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsObjectPipe, "isObject", true>;
+}
+
+/**
+ * IsFunctionPipe: Returns `true` when the value is callable.
+ *
+ * Backed by `typeof value === 'function'`, so arrow functions, regular
+ * functions, async functions, generator functions, and class constructors
+ * all return `true`. Methods and bound functions count too.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is a function, `false` otherwise.
+ *
+ * @example
+ * {{ (() => 0) | isFunction }} // true
+ * {{ Math.max | isFunction }}  // true
+ * {{ class {} | isFunction }}  // true
+ * {{ 'fn' | isFunction }}      // false
+ */
+declare class IsFunctionPipe implements PipeTransform {
+    transform(value: unknown): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsFunctionPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsFunctionPipe, "isFunction", true>;
+}
+
+/**
+ * IsEmptyPipe: Returns `true` when the value has nothing in it.
+ *
+ * - `null` / `undefined` → `true`
+ * - `''` (empty string) → `true`
+ * - `[]` (empty array) → `true`
+ * - `{}` (no own enumerable keys) → `true`
+ * - empty `Map` / `Set` → `true`
+ * - everything else (numbers, booleans, dates, functions, non-empty containers) → `false`
+ *
+ * Whitespace strings count as non-empty — chain `trim` first if you want a
+ * "blank" check.
+ *
+ * @param {unknown} value - The value to test.
+ *
+ * @returns {boolean} - `true` if the value is considered empty.
+ *
+ * @example
+ * {{ '' | isEmpty }}       // true
+ * {{ [] | isEmpty }}       // true
+ * {{ {} | isEmpty }}       // true
+ * {{ null | isEmpty }}     // true
+ * {{ ' ' | isEmpty }}      // false (use trim first)
+ * {{ 0 | isEmpty }}        // false
+ */
+declare class IsEmptyPipe implements PipeTransform {
+    transform(value: unknown): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsEmptyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsEmptyPipe, "isEmpty", true>;
+}
+
 /**
  * CreditCardMaskPipe: Masks all but the last four digits of a string, optionally controlled by a boolean flag.
  * By default, masking is applied.
@@ -1048,7 +1864,289 @@ declare class FilterByPipe implements PipeTransform {
     static ɵpipe: i0.ɵɵPipeDeclaration<FilterByPipe, "filterBy", true>;
 }
 
+/**
+ * MinPipe: Returns the minimum value from an array of numbers or objects.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {number | undefined} - The minimum value, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [5, 3, 8, 1, 9] | min }}                              // 1
+ * {{ products | min:'price' }}                               // cheapest price
+ * {{ orders | min:'meta.total' }}                            // lowest order total
+ */
+declare class MinPipe implements PipeTransform {
+    transform(value: unknown[], key?: string): number | undefined;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MinPipe, "min", true>;
+}
+
+/**
+ * MaxPipe: Returns the maximum value from an array of numbers or objects.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object comparison (supports dot notation).
+ *
+ * @returns {number | undefined} - The maximum value, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [5, 3, 8, 1, 9] | max }}                              // 9
+ * {{ products | max:'price' }}                               // highest price
+ * {{ orders | max:'meta.total' }}                            // largest order total
+ */
+declare class MaxPipe implements PipeTransform {
+    transform(value: unknown[], key?: string): number | undefined;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaxPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MaxPipe, "max", true>;
+}
+
+/**
+ * SumPipe: Returns the sum of all numeric values in an array.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object summation (supports dot notation).
+ *
+ * @returns {number | undefined} - The total, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [10, 20, 30] | sum }}                                  // 60
+ * {{ items | sum:'price' }}                                  // total price
+ * {{ orders | sum:'meta.total' }}                            // grand total
+ */
+declare class SumPipe implements PipeTransform {
+    transform(value: unknown[], key?: string): number | undefined;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SumPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SumPipe, "sum", true>;
+}
+
+/**
+ * AveragePipe: Returns the arithmetic mean of all numeric values in an array.
+ *
+ * Supports primitive number arrays and object arrays by property key with dot notation.
+ *
+ * @param {unknown[]} value - The array to evaluate.
+ * @param {string} [key] - Optional property path for object averaging (supports dot notation).
+ *
+ * @returns {number | undefined} - The average, or undefined if the array is empty/invalid.
+ *
+ * @example
+ * {{ [10, 20, 30] | average }}                              // 20
+ * {{ students | average:'grade' }}                           // average grade
+ * {{ reviews | average:'meta.rating' }}                      // average rating
+ */
+declare class AveragePipe implements PipeTransform {
+    transform(value: unknown[], key?: string): number | undefined;
+    private getNestedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AveragePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AveragePipe, "average", true>;
+}
+
+/**
+ * PercentagePipe: Calculates what percentage a value represents of a total.
+ *
+ * Returns `(value / total) * 100`, optionally rounded to a given number of decimal places.
+ *
+ * @param {number} value - The partial value.
+ * @param {number} total - The total/whole value.
+ * @param {number} [decimals] - Optional number of decimal places to round to.
+ *
+ * @returns {number | undefined} - The percentage, or undefined if inputs are invalid.
+ *
+ * @example
+ * {{ 25 | percentage:200 }}                                 // 12.5
+ * {{ 1 | percentage:3:2 }}                                  // 33.33
+ * {{ 750 | percentage:1000 }}                               // 75
+ */
+declare class PercentagePipe implements PipeTransform {
+    transform(value: number, total: number, decimals?: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PercentagePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PercentagePipe, "percentage", true>;
+}
+
+/**
+ * CeilPipe: Rounds a number up to the specified number of decimal places.
+ *
+ * Uses `Math.ceil` — always rounds toward positive infinity.
+ *
+ * @param {number} value - The number to round up.
+ * @param {number} [precision=0] - Number of decimal places to preserve (defaults to 0 = integer).
+ *
+ * @returns {number | undefined} - The rounded-up value, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 4.1 | ceil }}                                           // 5
+ * {{ 4.123 | ceil:2 }}                                       // 4.13
+ * {{ 0.001 | ceil:2 }}                                       // 0.01
+ * {{ -4.9 | ceil }}                                          // -4
+ */
+declare class CeilPipe implements PipeTransform {
+    transform(value: number, precision?: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CeilPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CeilPipe, "ceil", true>;
+}
+
+/**
+ * FloorPipe: Rounds a number down to the specified number of decimal places.
+ *
+ * Uses `Math.floor` — always rounds toward negative infinity.
+ *
+ * @param {number} value - The number to round down.
+ * @param {number} [precision=0] - Number of decimal places to preserve (defaults to 0 = integer).
+ *
+ * @returns {number | undefined} - The rounded-down value, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 4.9 | floor }}                                          // 4
+ * {{ 4.567 | floor:2 }}                                      // 4.56
+ * {{ 0.999 | floor:1 }}                                      // 0.9
+ * {{ -4.1 | floor }}                                         // -5
+ */
+declare class FloorPipe implements PipeTransform {
+    transform(value: number, precision?: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FloorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FloorPipe, "floor", true>;
+}
+
+/**
+ * RoundPipe: Rounds a number to the nearest value at the specified number of decimal places.
+ *
+ * Uses `Math.round` — rounds half-up (e.g. 2.5 → 3, -2.5 → -2).
+ *
+ * @param {number} value - The number to round.
+ * @param {number} [precision=0] - Number of decimal places to preserve (defaults to 0 = integer).
+ *
+ * @returns {number | undefined} - The rounded value, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 4.4 | round }}                                          // 4
+ * {{ 4.5 | round }}                                          // 5
+ * {{ 4.567 | round:2 }}                                      // 4.57
+ * {{ 0.125 | round:2 }}                                      // 0.13
+ */
+declare class RoundPipe implements PipeTransform {
+    transform(value: number, precision?: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RoundPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RoundPipe, "round", true>;
+}
+
+/**
+ * SqrtPipe: Returns the square root of a number.
+ *
+ * Uses `Math.sqrt`. Returns undefined for negative numbers.
+ *
+ * @param {number} value - The number to compute the square root of.
+ *
+ * @returns {number | undefined} - The square root, or undefined if the input is invalid or negative.
+ *
+ * @example
+ * {{ 9 | sqrt }}                                             // 3
+ * {{ 2 | sqrt }}                                             // 1.4142135623730951
+ * {{ 144 | sqrt }}                                           // 12
+ */
+declare class SqrtPipe implements PipeTransform {
+    transform(value: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SqrtPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SqrtPipe, "sqrt", true>;
+}
+
+/**
+ * PowPipe: Raises a number to the specified power.
+ *
+ * Uses `Math.pow`. The exponent defaults to 2 (squaring).
+ *
+ * @param {number} value - The base number.
+ * @param {number} [exponent=2] - The power to raise the base to (defaults to 2).
+ *
+ * @returns {number | undefined} - The result, or undefined if the inputs are invalid.
+ *
+ * @example
+ * {{ 3 | pow }}                                              // 9  (3^2)
+ * {{ 2 | pow:3 }}                                            // 8  (2^3)
+ * {{ 5 | pow:0 }}                                            // 1  (anything^0)
+ */
+declare class PowPipe implements PipeTransform {
+    transform(value: number, exponent?: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PowPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PowPipe, "pow", true>;
+}
+
+/**
+ * DegreesPipe: Converts a value in radians to degrees.
+ *
+ * Formula: `degrees = radians * (180 / Math.PI)`
+ *
+ * @param {number} value - The angle in radians.
+ *
+ * @returns {number | undefined} - The angle in degrees, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 3.14159 | degrees }}                                    // ~180
+ * {{ 1.5708 | degrees }}                                     // ~90
+ * {{ 0 | degrees }}                                          // 0
+ */
+declare class DegreesPipe implements PipeTransform {
+    transform(value: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DegreesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DegreesPipe, "degrees", true>;
+}
+
+/**
+ * BytesPipe: Formats a number of bytes into a human-readable string with appropriate units.
+ *
+ * Supports both binary (1024-based: KiB, MiB, GiB) and decimal (1000-based: KB, MB, GB) units.
+ * Defaults to decimal (1000-based) units.
+ *
+ * @param {number} value - The number of bytes.
+ * @param {number} [decimals=1] - Number of decimal places in the output.
+ * @param {string} [base='decimal'] - Unit base: 'decimal' (1000, KB/MB/GB) or 'binary' (1024, KiB/MiB/GiB).
+ *
+ * @returns {string | undefined} - The formatted string, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 1536 | bytes }}                                         // "1.5 KB"
+ * {{ 1048576 | bytes:2 }}                                    // "1.05 MB"
+ * {{ 1073741824 | bytes:1:'binary' }}                        // "1.0 GiB"
+ */
+declare class BytesPipe implements PipeTransform {
+    private readonly decimalUnits;
+    private readonly binaryUnits;
+    transform(value: number, decimals?: number, base?: 'decimal' | 'binary'): string | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BytesPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<BytesPipe, "bytes", true>;
+}
+
+/**
+ * RadiansPipe: Converts a value in degrees to radians.
+ *
+ * Formula: `radians = degrees * (Math.PI / 180)`
+ *
+ * @param {number} value - The angle in degrees.
+ *
+ * @returns {number | undefined} - The angle in radians, or undefined if the input is invalid.
+ *
+ * @example
+ * {{ 180 | radians }}                                        // ~3.14159
+ * {{ 90 | radians }}                                         // ~1.5708
+ * {{ 0 | radians }}                                          // 0
+ */
+declare class RadiansPipe implements PipeTransform {
+    transform(value: number): number | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadiansPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RadiansPipe, "radians", true>;
+}
+
 declare const ALL_PIPES: Provider[];
 
-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 { ALL_PIPES, AsciiArtPipe, AveragePipe, BarcodePipe, BytesPipe, CamelCasePipe, CapitalizePipe, CeilPipe, ChunkPipe, ColorConvertPipe, CountPipe, CreditCardMaskPipe, DecodeUriComponentPipe, DecodeUriPipe, DegreesPipe, DeviceTypePipe, DiffObjPipe, DiffPipe, EmailMaskPipe, EncodeUriComponentPipe, EncodeUriPipe, EveryPipe, FilterByPipe, Flatten, FloorPipe, GravatarPipe, GroupByPipe, HighlightPipe, HtmlEscapePipe, HtmlSanitizePipe, InitialPipe, InitialsPipe, IntersectionPipe, InvertByPipe, InvertPipe, IpAddressMaskPipe, IsArrayPipe, IsDefinedPipe, IsEmptyPipe, IsFunctionPipe, IsNullPipe, IsNumberPipe, IsObjectPipe, IsStringPipe, JsonPrettyPipe, KebabCasePipe, KeysPipe, LatinizePipe, LeftPadPipe, MatchPipe, MaxPipe, MinPipe, MorseCodePipe, NewlinesPipe, OmitPipe, OrderByPipe, PadPipe, PairsPipe, PercentagePipe, PickPipe, PluckPipe, PowPipe, QrCodePipe, RadiansPipe, RangePipe, RepeatPipe, ReplacePipe, ReversePipe, RightPadPipe, RoundPipe, SamplePipe, ShufflePipe, SlugifyPipe, SnakeCasePipe, SomePipe, SplitPipe, SqrtPipe, StripTagsPipe, SumPipe, TailPipe, TemplatePipe, TestPipe, TextToSpeechPipe, TimeAgoPipePipe, TitleCasePipe, TrimPipe, TruncatePipe, TruthifyPipe, UnionPipe, UniquePipe, UpperFirstPipe, ValuesPipe, WithoutPipe, WrapPipe };
 export type { AsciiArtOptions, BarcodeElementType, BarcodeFormat, BarcodeOptions, ColorTargetType, DeviceType, QrCodeOptions };