@abdokouta/react-support 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,1749 @@
+export { Collection as CollectJsCollection } from 'collect.js';
+import { Newable, ModuleContainer, ServiceIdentifier } from '@abdokouta/react-di';
+export { ModuleContainer, Newable, ServiceIdentifier } from '@abdokouta/react-di';
+
+/**
+ * Laravel-style string manipulation class
+ * Provides static methods for common string operations
+ */
+declare class Str {
+    /**
+     * Return the remainder of a string after the first occurrence of a given value
+     */
+    static after(subject: string, search: string): string;
+    /**
+     * Return the remainder of a string after the last occurrence of a given value
+     */
+    static afterLast(subject: string, search: string): string;
+    /**
+     * Convert a string to title case following APA guidelines
+     */
+    static apa(value: string): string;
+    /**
+     * Transliterate a UTF-8 value to ASCII
+     */
+    static ascii(value: string): string;
+    /**
+     * Get the portion of a string before the first occurrence of a given value
+     */
+    static before(subject: string, search: string): string;
+    /**
+     * Get the portion of a string before the last occurrence of a given value
+     */
+    static beforeLast(subject: string, search: string): string;
+    /**
+     * Get the portion of a string between two values
+     */
+    static between(subject: string, from: string, to: string): string;
+    /**
+     * Get the smallest possible portion of a string between two values
+     */
+    static betweenFirst(subject: string, from: string, to: string): string;
+    /**
+     * Convert a string to camelCase
+     */
+    static camel(value: string): string;
+    /**
+     * Get the character at the specified index
+     */
+    static charAt(subject: string, index: number): string | false;
+    /**
+     * Remove the first occurrence of the given value from the start of the string
+     */
+    static chopStart(subject: string, search: string | string[]): string;
+    /**
+     * Remove the last occurrence of the given value from the end of the string
+     */
+    static chopEnd(subject: string, search: string | string[]): string;
+    /**
+     * Determine if a given string contains a given substring
+     */
+    static contains(haystack: string, needles: string | string[], ignoreCase?: boolean): boolean;
+    /**
+     * Determine if a given string contains all array values
+     */
+    static containsAll(haystack: string, needles: string[], ignoreCase?: boolean): boolean;
+    /**
+     * Determine if a given string doesn't contain a given substring
+     */
+    static doesntContain(haystack: string, needles: string | string[], ignoreCase?: boolean): boolean;
+    /**
+     * Replace consecutive instances of a character with a single instance
+     */
+    static deduplicate(value: string, character?: string): string;
+    /**
+     * Determine if a given string ends with a given substring
+     */
+    static endsWith(haystack: string, needles: string | string[]): boolean;
+    /**
+     * Extract an excerpt from text that matches the first instance of a phrase
+     */
+    static excerpt(text: string, phrase: string, options?: {
+        radius?: number;
+        omission?: string;
+    }): string;
+    /**
+     * Cap a string with a single instance of a given value
+     */
+    static finish(value: string, cap: string): string;
+    /**
+     * Convert a string to headline case
+     */
+    static headline(value: string): string;
+    /**
+     * Determine if a given string matches a given pattern
+     */
+    static is(pattern: string, value: string, ignoreCase?: boolean): boolean;
+    /**
+     * Determine if a given string is 7-bit ASCII
+     */
+    static isAscii(value: string): boolean;
+    /**
+     * Determine if a given string is valid JSON
+     */
+    static isJson(value: string): boolean;
+    /**
+     * Determine if a given string is a valid URL
+     */
+    static isUrl(value: string, protocols?: string[]): boolean;
+    /**
+     * Determine if a given string is a valid ULID
+     */
+    static isUlid(value: string): boolean;
+    /**
+     * Determine if a given string is a valid UUID
+     */
+    static isUuid(value: string): boolean;
+    /**
+     * Convert a string to kebab-case
+     */
+    static kebab(value: string): string;
+    /**
+     * Return the given string with the first character lowercased
+     */
+    static lcfirst(value: string): string;
+    /**
+     * Return the length of the given string
+     */
+    static len(value: string): number;
+    /**
+     * Limit the number of characters in a string
+     */
+    static limit(value: string, limit?: number, end?: string, preserveWords?: boolean): string;
+    /**
+     * Convert the given string to lowercase
+     */
+    static lower(value: string): string;
+    /**
+     * Masks a portion of a string with a repeated character
+     */
+    static mask(value: string, character: string, index: number, length?: number): string;
+    /**
+     * Pad both sides of a string with another
+     */
+    static padBoth(value: string, length: number, pad?: string): string;
+    /**
+     * Pad the left side of a string with another
+     */
+    static padLeft(value: string, length: number, pad?: string): string;
+    /**
+     * Pad the right side of a string with another
+     */
+    static padRight(value: string, length: number, pad?: string): string;
+    /**
+     * Get the plural form of an English word
+     */
+    static plural(value: string, count?: number): string;
+    /**
+     * Pluralize the last word of an English, studly caps case string
+     */
+    static pluralStudly(value: string, count?: number): string;
+    /**
+     * Find the position of the first occurrence of a substring
+     */
+    static position(haystack: string, needle: string): number | false;
+    /**
+     * Generate a random string
+     */
+    static random(length?: number): string;
+    /**
+     * Remove the given value from the string
+     */
+    static remove(search: string | string[], subject: string, caseSensitive?: boolean): string;
+    /**
+     * Repeat the given string
+     */
+    static repeat(value: string, times: number): string;
+    /**
+     * Replace the given value in the given string
+     */
+    static replace(search: string, replace: string, subject: string, caseSensitive?: boolean): string;
+    /**
+     * Replace a given value in the string sequentially with an array
+     */
+    static replaceArray(search: string, replacements: string[], subject: string): string;
+    /**
+     * Replace the first occurrence of a given value in the string
+     */
+    static replaceFirst(search: string, replace: string, subject: string): string;
+    /**
+     * Replace the last occurrence of a given value in the string
+     */
+    static replaceLast(search: string, replace: string, subject: string): string;
+    /**
+     * Replace the first occurrence only if it appears at the start
+     */
+    static replaceStart(search: string, replace: string, subject: string): string;
+    /**
+     * Replace the last occurrence only if it appears at the end
+     */
+    static replaceEnd(search: string, replace: string, subject: string): string;
+    /**
+     * Reverse the given string
+     */
+    static reverse(value: string): string;
+    /**
+     * Get the singular form of an English word
+     */
+    static singular(value: string): string;
+    /**
+     * Generate a URL friendly slug
+     */
+    static slug(value: string, separator?: string): string;
+    /**
+     * Convert a string to snake_case
+     */
+    static snake(value: string, delimiter?: string): string;
+    /**
+     * Remove all extraneous whitespace
+     */
+    static squish(value: string): string;
+    /**
+     * Begin a string with a single instance of a given value
+     */
+    static start(value: string, prefix: string): string;
+    /**
+     * Determine if a given string starts with a given substring
+     */
+    static startsWith(haystack: string, needles: string | string[]): boolean;
+    /**
+     * Convert a value to studly caps case
+     */
+    static studly(value: string): string;
+    /**
+     * Returns the portion of string specified by the start and length parameters
+     */
+    static substr(value: string, start: number, length?: number): string;
+    /**
+     * Returns the number of substring occurrences
+     */
+    static substrCount(haystack: string, needle: string): number;
+    /**
+     * Replace text within a portion of a string
+     */
+    static substrReplace(value: string, replace: string, start: number, length?: number): string;
+    /**
+     * Swap multiple keywords in a string with other keywords
+     */
+    static swap(map: Record<string, string>, subject: string): string;
+    /**
+     * Take the first or last {limit} characters
+     */
+    static take(value: string, limit: number): string;
+    /**
+     * Convert the given string to title case
+     */
+    static title(value: string): string;
+    /**
+     * Convert the given string to Base64
+     */
+    static toBase64(value: string): string;
+    /**
+     * Transliterate a string to its closest ASCII representation
+     */
+    static transliterate(value: string): string;
+    /**
+     * Trim whitespace from both ends of the string
+     */
+    static trim(value: string, characters?: string): string;
+    /**
+     * Trim whitespace from the beginning of the string
+     */
+    static ltrim(value: string, characters?: string): string;
+    /**
+     * Trim whitespace from the end of the string
+     */
+    static rtrim(value: string, characters?: string): string;
+    /**
+     * Make a string's first character uppercase
+     */
+    static ucfirst(value: string): string;
+    /**
+     * Split a string by uppercase characters
+     */
+    static ucsplit(value: string): string[];
+    /**
+     * Convert the given string to uppercase
+     */
+    static upper(value: string): string;
+    /**
+     * Remove the specified strings from the beginning and end
+     */
+    static unwrap(value: string, before: string, after?: string): string;
+    /**
+     * Get the number of words a string contains
+     */
+    static wordCount(value: string): number;
+    /**
+     * Wrap a string to a given number of characters
+     */
+    static wordWrap(value: string, characters?: number, breakStr?: string): string;
+    /**
+     * Limit the number of words in a string
+     */
+    static words(value: string, words?: number, end?: string): string;
+    /**
+     * Wrap the string with the given strings
+     */
+    static wrap(value: string, before: string, after?: string): string;
+}
+
+declare class Collection$1<T = any> {
+    private collection;
+    constructor(items?: T[]);
+    /**
+     * Create a new collection instance
+     */
+    static make<T>(items?: T[]): Collection$1<T>;
+    /**
+     * Get all items in the collection
+     */
+    all(): T[];
+    /**
+     * Get the average value of a given key
+     */
+    avg(key?: keyof T | ((item: T) => number)): number;
+    /**
+     * Chunk the collection into chunks of the given size
+     */
+    chunk(size: number): Collection$1<T[]>;
+    /**
+     * Collapse a collection of arrays into a single, flat collection
+     */
+    collapse(): Collection$1<any>;
+    /**
+     * Determine if an item exists in the collection
+     */
+    contains(key: keyof T | ((item: T) => boolean), value?: any): boolean;
+    /**
+     * Get the total number of items in the collection
+     */
+    count(): number;
+    /**
+     * Get the items in the collection that are not present in the given items
+     */
+    diff(items: T[]): Collection$1<T>;
+    /**
+     * Execute a callback over each item
+     */
+    each(callback: (item: T, key: number) => void | false): this;
+    /**
+     * Determine if all items pass the given test
+     */
+    every(callback: (item: T, key: number) => boolean): boolean;
+    /**
+     * Get all items except for those with the specified keys
+     */
+    except(keys: (keyof T)[]): Collection$1<T>;
+    /**
+     * Run a filter over each of the items
+     */
+    filter(callback?: (item: T, key: number) => boolean): Collection$1<T>;
+    /**
+     * Get the first item from the collection
+     */
+    first(callback?: (item: T, key: number) => boolean): T | undefined;
+    /**
+     * Get a flattened array of the items in the collection
+     */
+    flatten(depth?: number): Collection$1<any>;
+    /**
+     * Flip the items in the collection
+     */
+    flip(): Collection$1<any>;
+    /**
+     * Remove an item from the collection by key
+     */
+    forget(key: number): this;
+    /**
+     * Get an item from the collection by key
+     */
+    get(key: number, defaultValue?: T): T | undefined;
+    /**
+     * Group the collection's items by a given key
+     */
+    groupBy(key: keyof T | ((item: T) => any)): Collection$1<Collection$1<T>>;
+    /**
+     * Determine if a given key exists in the collection
+     */
+    has(key: number): boolean;
+    /**
+     * Concatenate values of a given key as a string
+     */
+    implode(key: keyof T | string, glue?: string): string;
+    /**
+     * Intersect the collection with the given items
+     */
+    intersect(items: T[]): Collection$1<T>;
+    /**
+     * Determine if the collection is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Determine if the collection is not empty
+     */
+    isNotEmpty(): boolean;
+    /**
+     * Join all items from the collection using a string
+     */
+    join(glue: string, finalGlue?: string): string;
+    /**
+     * Key the collection by the given key
+     */
+    keyBy(key: keyof T | ((item: T) => any)): Collection$1<T>;
+    /**
+     * Get the keys of the collection items
+     */
+    keys(): Collection$1<string | number>;
+    /**
+     * Get the last item from the collection
+     */
+    last(callback?: (item: T, key: number) => boolean): T | undefined;
+    /**
+     * Run a map over each of the items
+     */
+    map<U>(callback: (item: T, key: number) => U): Collection$1<U>;
+    /**
+     * Get the max value of a given key
+     */
+    max(key?: keyof T): number;
+    /**
+     * Merge the collection with the given items
+     */
+    merge(items: T[]): Collection$1<T>;
+    /**
+     * Get the min value of a given key
+     */
+    min(key?: keyof T): number;
+    /**
+     * Get the items with the specified keys
+     */
+    only(keys: (keyof T)[]): Collection$1<T>;
+    /**
+     * Get and remove the last item from the collection
+     */
+    pop(): T | undefined;
+    /**
+     * Push an item onto the beginning of the collection
+     */
+    prepend(value: T): this;
+    /**
+     * Get and remove an item from the collection
+     */
+    pull(key: number): T | undefined;
+    /**
+     * Push an item onto the end of the collection
+     */
+    push(value: T): this;
+    /**
+     * Put an item in the collection by key
+     */
+    put(key: number, value: T): this;
+    /**
+     * Get one or a specified number of items randomly from the collection
+     */
+    random(count?: number): T | Collection$1<T>;
+    /**
+     * Reduce the collection to a single value
+     */
+    reduce<U>(callback: (carry: U, item: T) => U, initial: U): U;
+    /**
+     * Filter items by the given key value pair
+     */
+    reject(callback: (item: T, key: number) => boolean): Collection$1<T>;
+    /**
+     * Reverse items order
+     */
+    reverse(): Collection$1<T>;
+    /**
+     * Search the collection for a given value
+     */
+    search(value: T | ((item: T) => boolean)): number | false;
+    /**
+     * Get and remove the first item from the collection
+     */
+    shift(): T | undefined;
+    /**
+     * Shuffle the items in the collection
+     */
+    shuffle(): Collection$1<T>;
+    /**
+     * Slice the underlying collection array
+     */
+    slice(start: number, length?: number): Collection$1<T>;
+    /**
+     * Sort through each item with a callback
+     */
+    sort(callback?: (a: T, b: T) => number): Collection$1<T>;
+    /**
+     * Sort the collection by the given key
+     */
+    sortBy(key: keyof T | ((item: T) => any)): Collection$1<T>;
+    /**
+     * Sort the collection in descending order by the given key
+     */
+    sortByDesc(key: keyof T | ((item: T) => any)): Collection$1<T>;
+    /**
+     * Splice a portion of the underlying collection array
+     */
+    splice(start: number, length?: number, ...items: T[]): Collection$1<T>;
+    /**
+     * Get the sum of the given values
+     */
+    sum(key?: keyof T | ((item: T) => number)): number;
+    /**
+     * Take the first or last {limit} items
+     */
+    take(limit: number): Collection$1<T>;
+    /**
+     * Pass the collection to the given callback and return the result
+     */
+    pipe<U>(callback: (collection: Collection$1<T>) => U): U;
+    /**
+     * Pass the collection to the given callback and then return it
+     */
+    tap(callback: (collection: Collection$1<T>) => void): this;
+    /**
+     * Transform each item in the collection using a callback
+     */
+    transform(callback: (item: T, key: number) => T): this;
+    /**
+     * Return only unique items from the collection array
+     */
+    unique(key?: keyof T): Collection$1<T>;
+    /**
+     * Reset the keys on the underlying array
+     */
+    values(): Collection$1<T>;
+    /**
+     * Filter items by the given key value pair
+     */
+    where(key: keyof T, value: any): Collection$1<T>;
+    where(key: keyof T, operator: string, value: any): Collection$1<T>;
+    /**
+     * Filter items by the given key value pair using loose comparison
+     */
+    whereIn(key: keyof T, values: any[]): Collection$1<T>;
+    /**
+     * Filter items by the given key value pair using loose comparison
+     */
+    whereNotIn(key: keyof T, values: any[]): Collection$1<T>;
+    /**
+     * Zip the collection together with one or more arrays
+     */
+    zip<U>(...arrays: U[][]): Collection$1<any[]>;
+    /**
+     * Convert the collection to a plain array
+     */
+    toArray(): T[];
+    /**
+     * Convert the collection to JSON
+     */
+    toJson(): string;
+    /**
+     * Get the collection as a string
+     */
+    toString(): string;
+}
+/**
+ * Helper function to create a new collection
+ */
+declare function collect<T>(items?: T[]): Collection$1<T>;
+
+/**
+ * Laravel-style Map Collection class
+ * Provides collection methods for Map data structures
+ */
+declare class MapCollection<K = any, V = any> {
+    private internalMap;
+    constructor(entries?: Iterable<[K, V]> | Record<string, V>);
+    /**
+     * Create a new map collection instance
+     */
+    static make<K, V>(entries?: Iterable<[K, V]> | Record<string, V>): MapCollection<K, V>;
+    /**
+     * Get all entries as an array of [key, value] pairs
+     */
+    all(): [K, V][];
+    /**
+     * Get the number of items in the map
+     */
+    count(): number;
+    /**
+     * Get the number of items in the map (alias for count)
+     */
+    size(): number;
+    /**
+     * Determine if the map is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Determine if the map is not empty
+     */
+    isNotEmpty(): boolean;
+    /**
+     * Determine if a key exists in the map
+     */
+    has(key: K): boolean;
+    /**
+     * Get a value from the map by key
+     */
+    get(key: K, defaultValue?: V): V | undefined;
+    /**
+     * Set a value in the map
+     */
+    set(key: K, value: V): this;
+    /**
+     * Put a value in the map (alias for set)
+     */
+    put(key: K, value: V): this;
+    /**
+     * Remove a key from the map
+     */
+    delete(key: K): boolean;
+    /**
+     * Remove a key from the map (alias for delete)
+     */
+    forget(key: K): boolean;
+    /**
+     * Remove all items from the map
+     */
+    clear(): this;
+    /**
+     * Get all keys from the map
+     */
+    keys(): K[];
+    /**
+     * Get all values from the map
+     */
+    values(): V[];
+    /**
+     * Execute a callback over each item
+     */
+    each(callback: (value: V, key: K) => void | false): this;
+    /**
+     * Run a map over each of the items
+     */
+    mapValues<U>(callback: (value: V, key: K) => U): MapCollection<K, U>;
+    /**
+     * Run a filter over each of the items
+     */
+    filter(callback: (value: V, key: K) => boolean): MapCollection<K, V>;
+    /**
+     * Determine if all items pass the given test
+     */
+    every(callback: (value: V, key: K) => boolean): boolean;
+    /**
+     * Determine if any item passes the given test
+     */
+    some(callback: (value: V, key: K) => boolean): boolean;
+    /**
+     * Get the first value that passes the given test
+     */
+    first(callback?: (value: V, key: K) => boolean): V | undefined;
+    /**
+     * Get the last value that passes the given test
+     */
+    last(callback?: (value: V, key: K) => boolean): V | undefined;
+    /**
+     * Reduce the map to a single value
+     */
+    reduce<U>(callback: (carry: U, value: V, key: K) => U, initial: U): U;
+    /**
+     * Merge another map into this one
+     */
+    merge(other: MapCollection<K, V> | Map<K, V> | Record<string, V>): this;
+    /**
+     * Get only the specified keys
+     */
+    only(keys: K[]): MapCollection<K, V>;
+    /**
+     * Get all items except the specified keys
+     */
+    except(keys: K[]): MapCollection<K, V>;
+    /**
+     * Flip the keys and values
+     */
+    flip(): MapCollection<V, K>;
+    /**
+     * Pass the map to the given callback and return the result
+     */
+    pipe<U>(callback: (map: MapCollection<K, V>) => U): U;
+    /**
+     * Pass the map to the given callback and then return it
+     */
+    tap(callback: (map: MapCollection<K, V>) => void): this;
+    /**
+     * Convert the map to a plain object
+     */
+    toObject(): Record<string, V>;
+    /**
+     * Convert the map to an array of [key, value] pairs
+     */
+    toArray(): [K, V][];
+    /**
+     * Convert the map to JSON
+     */
+    toJson(): string;
+    /**
+     * Get the map as a string
+     */
+    toString(): string;
+    /**
+     * Get the underlying Map instance
+     */
+    toMap(): Map<K, V>;
+}
+/**
+ * Helper function to create a new map collection
+ */
+declare function collectMap<K, V>(entries?: Iterable<[K, V]> | Record<string, V>): MapCollection<K, V>;
+
+/**
+ * Laravel-style Set Collection class
+ * Provides collection methods for Set data structures
+ */
+declare class SetCollection<T = any> {
+    private set;
+    constructor(items?: Iterable<T>);
+    /**
+     * Create a new set collection instance
+     */
+    static make<T>(items?: Iterable<T>): SetCollection<T>;
+    /**
+     * Get all items as an array
+     */
+    all(): T[];
+    /**
+     * Get the number of items in the set
+     */
+    count(): number;
+    /**
+     * Get the number of items in the set (alias for count)
+     */
+    size(): number;
+    /**
+     * Determine if the set is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Determine if the set is not empty
+     */
+    isNotEmpty(): boolean;
+    /**
+     * Determine if an item exists in the set
+     */
+    has(item: T): boolean;
+    /**
+     * Determine if an item exists in the set (alias for has)
+     */
+    contains(item: T): boolean;
+    /**
+     * Add an item to the set
+     */
+    add(item: T): this;
+    /**
+     * Add an item to the set (alias for add)
+     */
+    push(item: T): this;
+    /**
+     * Remove an item from the set
+     */
+    delete(item: T): boolean;
+    /**
+     * Remove an item from the set (alias for delete)
+     */
+    forget(item: T): boolean;
+    /**
+     * Remove all items from the set
+     */
+    clear(): this;
+    /**
+     * Execute a callback over each item
+     */
+    each(callback: (item: T, index: number) => void | false): this;
+    /**
+     * Run a map over each of the items
+     */
+    map<U>(callback: (item: T, index: number) => U): SetCollection<U>;
+    /**
+     * Run a filter over each of the items
+     */
+    filter(callback: (item: T, index: number) => boolean): SetCollection<T>;
+    /**
+     * Determine if all items pass the given test
+     */
+    every(callback: (item: T, index: number) => boolean): boolean;
+    /**
+     * Determine if any item passes the given test
+     */
+    some(callback: (item: T, index: number) => boolean): boolean;
+    /**
+     * Get the first item that passes the given test
+     */
+    first(callback?: (item: T, index: number) => boolean): T | undefined;
+    /**
+     * Get the last item that passes the given test
+     */
+    last(callback?: (item: T, index: number) => boolean): T | undefined;
+    /**
+     * Reduce the set to a single value
+     */
+    reduce<U>(callback: (carry: U, item: T, index: number) => U, initial: U): U;
+    /**
+     * Merge another set into this one
+     */
+    merge(other: SetCollection<T> | Set<T> | T[]): this;
+    /**
+     * Get the union of this set and another
+     */
+    union(other: SetCollection<T> | Set<T> | T[]): SetCollection<T>;
+    /**
+     * Get the intersection of this set and another
+     */
+    intersect(other: SetCollection<T> | Set<T> | T[]): SetCollection<T>;
+    /**
+     * Get the difference between this set and another
+     */
+    diff(other: SetCollection<T> | Set<T> | T[]): SetCollection<T>;
+    /**
+     * Get items that are in either set but not in both
+     */
+    symmetricDiff(other: SetCollection<T> | Set<T> | T[]): SetCollection<T>;
+    /**
+     * Determine if this set is a subset of another
+     */
+    isSubsetOf(other: SetCollection<T> | Set<T> | T[]): boolean;
+    /**
+     * Determine if this set is a superset of another
+     */
+    isSupersetOf(other: SetCollection<T> | Set<T> | T[]): boolean;
+    /**
+     * Pass the set to the given callback and return the result
+     */
+    pipe<U>(callback: (set: SetCollection<T>) => U): U;
+    /**
+     * Pass the set to the given callback and then return it
+     */
+    tap(callback: (set: SetCollection<T>) => void): this;
+    /**
+     * Convert the set to an array
+     */
+    toArray(): T[];
+    /**
+     * Convert the set to JSON
+     */
+    toJson(): string;
+    /**
+     * Get the set as a string
+     */
+    toString(): string;
+    /**
+     * Get the underlying Set instance
+     */
+    toSet(): Set<T>;
+}
+/**
+ * Helper function to create a new set collection
+ */
+declare function collectSet<T>(items?: Iterable<T>): SetCollection<T>;
+
+/**
+ * @fileoverview Base registry implementation
+ *
+ * This file provides a generic base registry class that uses the Collection
+ * interface for storage. It provides a consistent API for all registry
+ * implementations across the application.
+ *
+ * Key Features:
+ * - Generic type support for any item type
+ * - Default item support (fallback when item not found)
+ * - Validation hooks (before add, after add)
+ * - Collection-based storage (efficient O(1) operations)
+ * - Type-safe API
+ * - Consistent interface across all registries
+ *
+ * Use Cases:
+ * - Theme registry (storing and retrieving themes)
+ * - Token registry (managing design tokens)
+ * - Plugin registry (managing plugins)
+ * - Configuration registry (storing configs)
+ * - Any key-value registry needs
+ *
+ * @module @pixielity/support
+ * @category Registries
+ */
+/**
+ * Collection interface for registry storage
+ */
+interface Collection<T> {
+    add(key: string, value: T): void;
+    get(key: string): T | undefined;
+    getAll(): T[];
+    getKeys(): string[];
+    getAsRecord(): Record<string, T>;
+    has(key: string): boolean;
+    remove(key: string): boolean;
+    clear(): void;
+    size(): number;
+    isEmpty(): boolean;
+    forEach(callback: (value: T, key: string) => void): void;
+    map<U>(callback: (value: T, key: string) => U): U[];
+    filter(predicate: (value: T, key: string) => boolean): T[];
+    find(predicate: (value: T, key: string) => boolean): T | undefined;
+}
+/**
+ * Validation result for registry operations
+ *
+ * Used by validation hooks to indicate whether an operation
+ * should proceed or be rejected.
+ *
+ * @example
+ * ```typescript
+ * const result: ValidationResult = {
+ *   valid: false,
+ *   error: 'Item name cannot be empty'
+ * };
+ * ```
+ */
+interface ValidationResult {
+    /**
+     * Whether the validation passed
+     */
+    valid: boolean;
+    /**
+     * Error message if validation failed
+     */
+    error?: string;
+}
+/**
+ * Base registry options
+ *
+ * Configuration options for creating a registry instance.
+ * Allows customization of default item behavior and validation.
+ *
+ * @template T - The type of items stored in the registry
+ */
+interface BaseRegistryOptions<T> {
+    /**
+     * Default item to return when requested item is not found
+     *
+     * If not provided, get() will return undefined for missing items.
+     * If provided, get() will return this default item instead.
+     */
+    defaultItem?: T;
+    /**
+     * Validation hook called before adding an item
+     *
+     * Allows custom validation logic before items are added to the registry.
+     * If validation fails, the item will not be added and an error will be thrown.
+     *
+     * @param key - Item key
+     * @param item - Item to validate
+     * @returns Validation result
+     */
+    validateBeforeAdd?: (key: string, item: T) => ValidationResult;
+    /**
+     * Hook called after an item is successfully added
+     *
+     * Useful for side effects like logging, notifications, or triggering
+     * dependent updates after an item is registered.
+     *
+     * @param key - Item key
+     * @param item - Item that was added
+     */
+    afterAdd?: (key: string, item: T) => void;
+}
+/**
+ * Base registry class
+ *
+ * A generic registry implementation that provides a consistent API for
+ * storing and retrieving items by key. Uses the Collection interface
+ * for efficient storage with O(1) operations.
+ *
+ * This class extends Collection functionality by adding:
+ * - Default item support
+ * - Validation hooks
+ * - Consistent registry API
+ *
+ * All Collection methods are directly accessible on the registry instance.
+ *
+ * Performance Characteristics:
+ * - register(): O(1) + validation time
+ * - get(): O(1)
+ * - has(): O(1)
+ * - remove(): O(1)
+ * - getAll(): O(n)
+ * - clear(): O(1)
+ *
+ * @template T - The type of items stored in the registry
+ *
+ * @example
+ * ```typescript
+ * // Create a theme registry
+ * const themeRegistry = new BaseRegistry<Theme>({
+ *   defaultItem: defaultTheme,
+ *   validateBeforeAdd: (key, theme) => {
+ *     if (!theme.name) {
+ *       return { valid: false, error: 'Theme must have a name' };
+ *     }
+ *     return { valid: true };
+ *   }
+ * });
+ *
+ * // Register themes
+ * themeRegistry.register('blue', blueTheme);
+ * themeRegistry.register('red', redTheme);
+ *
+ * // Get a theme
+ * const theme = themeRegistry.get('blue');
+ *
+ * // Get all themes
+ * const allThemes = themeRegistry.getAll();
+ *
+ * // Check if theme exists
+ * if (themeRegistry.has('blue')) {
+ *   console.log('Blue theme exists');
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create a simple token registry
+ * const tokenRegistry = new BaseRegistry<Token>();
+ *
+ * tokenRegistry.register('primary', { value: '#0000FF' });
+ * tokenRegistry.register('secondary', { value: '#FF0000' });
+ *
+ * const allTokens = tokenRegistry.getAll();
+ * console.log(allTokens.length); // 2
+ * ```
+ */
+declare class BaseRegistry<T> implements Collection<T> {
+    /**
+     * Internal collection for storing registry items
+     *
+     * Uses Collection interface for flexible storage implementation.
+     * By default, uses MapCollection for O(1) operations.
+     */
+    protected collection: Collection<T>;
+    /**
+     * Default item to return when requested item is not found
+     *
+     * If set, get() will return this item instead of undefined
+     * when the requested key doesn't exist in the registry.
+     */
+    protected defaultItem?: T;
+    /**
+     * Validation hook called before adding an item
+     *
+     * If provided, this function is called before every register()
+     * operation to validate the item. If validation fails, the
+     * item is not added and an error is thrown.
+     */
+    protected validateBeforeAdd?: (key: string, item: T) => ValidationResult;
+    /**
+     * Hook called after an item is successfully added
+     *
+     * If provided, this function is called after every successful
+     * register() operation. Useful for side effects like logging
+     * or triggering dependent updates.
+     */
+    protected afterAdd?: (key: string, item: T) => void;
+    /**
+     * Creates a new BaseRegistry instance
+     *
+     * Initializes the registry with optional configuration for default
+     * item and validation hooks. By default, uses MapCollection for storage.
+     *
+     * @param options - Registry configuration options
+     *
+     * @example
+     * ```typescript
+     * // Simple registry without options
+     * const registry = new BaseRegistry<Theme>();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Registry with default item
+     * const registry = new BaseRegistry<Theme>({
+     *   defaultItem: defaultTheme
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Registry with validation
+     * const registry = new BaseRegistry<Theme>({
+     *   validateBeforeAdd: (key, theme) => {
+     *     if (!theme.name) {
+     *       return { valid: false, error: 'Theme must have a name' };
+     *     }
+     *     return { valid: true };
+     *   },
+     *   afterAdd: (key, theme) => {
+     *     console.log(`Registered theme: ${theme.name}`);
+     *   }
+     * });
+     * ```
+     */
+    constructor(options?: BaseRegistryOptions<T>);
+    /**
+     * Register an item in the registry
+     *
+     * Adds or updates an item in the registry with the specified key.
+     * If an item with the same key already exists, it will be replaced.
+     *
+     * If a validation hook is configured, it will be called before adding
+     * the item. If validation fails, an error is thrown and the item is
+     * not added.
+     *
+     * If an afterAdd hook is configured, it will be called after the item
+     * is successfully added.
+     *
+     * Time Complexity: O(1) + validation time
+     *
+     * @param key - Unique identifier for the item
+     * @param item - Item to register
+     * @throws Error if validation fails
+     *
+     * @example
+     * ```typescript
+     * const registry = new BaseRegistry<Theme>();
+     *
+     * // Register a theme
+     * registry.register('blue', {
+     *   name: 'Blue',
+     *   colors: { accent: '#0000FF' }
+     * });
+     *
+     * // Update existing theme
+     * registry.register('blue', {
+     *   name: 'Blue',
+     *   colors: { accent: '#0066FF' }
+     * });
+     * ```
+     */
+    register(key: string, item: T): void;
+    /**
+     * Add an item to the collection (alias for register)
+     *
+     * This method is part of the Collection interface.
+     * It delegates to register() to ensure validation hooks are called.
+     *
+     * Time Complexity: O(1) + validation time
+     *
+     * @param key - Unique identifier for the item
+     * @param value - Item to add
+     */
+    add(key: string, value: T): void;
+    /**
+     * Get an item from the registry
+     *
+     * Retrieves an item by its key. If the item doesn't exist:
+     * - Returns the default item if one was configured
+     * - Returns undefined if no default item was configured
+     *
+     * Time Complexity: O(1)
+     *
+     * @param key - Item identifier
+     * @returns Item if found, default item if configured, or undefined
+     *
+     * @example
+     * ```typescript
+     * const theme = registry.get('blue');
+     * ```
+     */
+    get(key: string): T | undefined;
+    /**
+     * Get all items in the registry
+     *
+     * Returns an array containing all items in the registry.
+     * The order of items depends on the collection implementation
+     * (MapCollection maintains insertion order).
+     *
+     * Time Complexity: O(n) where n is the number of items
+     *
+     * @returns Array of all items in the registry
+     *
+     * @example
+     * ```typescript
+     * const allThemes = registry.getAll();
+     * ```
+     */
+    getAll(): T[];
+    /**
+     * Get all keys in the registry
+     *
+     * Returns an array containing all keys in the registry.
+     * Useful for iteration or checking what items are registered.
+     *
+     * Time Complexity: O(n) where n is the number of items
+     *
+     * @returns Array of all keys in the registry
+     *
+     * @example
+     * ```typescript
+     * const keys = registry.getKeys();
+     * ```
+     */
+    getKeys(): string[];
+    /**
+     * Get registry as a record object
+     *
+     * Converts the registry to a plain JavaScript object (record)
+     * with keys mapping to values. Useful for serialization.
+     *
+     * Time Complexity: O(n) where n is the number of items
+     *
+     * @returns Record object with keys mapping to values
+     *
+     * @example
+     * ```typescript
+     * const record = registry.getAsRecord();
+     * ```
+     */
+    getAsRecord(): Record<string, T>;
+    /**
+     * Check if an item is registered
+     *
+     * Checks whether an item with the specified key exists in the registry.
+     * Does not check the value, only the presence of the key.
+     *
+     * Time Complexity: O(1)
+     *
+     * @param key - Item identifier to check
+     * @returns True if item is registered, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (registry.has('blue')) {
+     *   console.log('Blue theme exists');
+     * }
+     * ```
+     */
+    has(key: string): boolean;
+    /**
+     * Remove an item from the registry
+     *
+     * Removes an item with the specified key from the registry.
+     * Returns true if the item was removed, false if it didn't exist.
+     *
+     * Time Complexity: O(1)
+     *
+     * @param key - Item identifier to remove
+     * @returns True if item was removed, false if it didn't exist
+     *
+     * @example
+     * ```typescript
+     * const removed = registry.remove('blue');
+     * ```
+     */
+    remove(key: string): boolean;
+    /**
+     * Clear all items from the registry
+     *
+     * Removes all items from the registry, leaving it empty.
+     * This operation is irreversible.
+     *
+     * Time Complexity: O(1)
+     *
+     * @example
+     * ```typescript
+     * registry.clear();
+     * ```
+     */
+    clear(): void;
+    /**
+     * Get the number of items in the registry
+     *
+     * Returns the total count of items currently registered.
+     *
+     * Time Complexity: O(1)
+     *
+     * @returns Number of items in the registry
+     *
+     * @example
+     * ```typescript
+     * console.log(registry.size()); // 2
+     * ```
+     */
+    size(): number;
+    /**
+     * Check if the registry is empty
+     *
+     * Returns true if the registry contains no items, false otherwise.
+     * This is a convenience method equivalent to checking if size() === 0.
+     *
+     * Time Complexity: O(1)
+     *
+     * @returns True if registry has no items, false otherwise
+     *
+     * @example
+     * ```typescript
+     * console.log(registry.isEmpty()); // true
+     * ```
+     */
+    isEmpty(): boolean;
+    /**
+     * Iterate over all items in the registry
+     *
+     * Executes a callback function for each item in the registry.
+     * Items are iterated in insertion order (for MapCollection).
+     *
+     * Time Complexity: O(n) where n is the number of items
+     *
+     * @param callback - Function to call for each item (value, key)
+     *
+     * @example
+     * ```typescript
+     * registry.forEach((theme, key) => {
+     *   console.log(`${key}: ${theme.name}`);
+     * });
+     * ```
+     */
+    forEach(callback: (value: T, key: string) => void): void;
+    /**
+     * Map over all items in the registry
+     *
+     * Transforms each item in the registry using a callback function
+     * and returns an array of the transformed values.
+     *
+     * Time Complexity: O(n) where n is the number of items
+     *
+     * @template U - The type of the transformed items
+     * @param callback - Function to transform each item (value, key) => U
+     * @returns Array of transformed items
+     *
+     * @example
+     * ```typescript
+     * const names = registry.map(theme => theme.name);
+     * ```
+     */
+    map<U>(callback: (value: T, key: string) => U): U[];
+    /**
+     * Filter items in the registry
+     *
+     * Returns an array of items that pass the test implemented by the
+     * provided predicate function.
+     *
+     * Time Complexity: O(n) where n is the number of items
+     *
+     * @param predicate - Function to test each item (value, key) => boolean
+     * @returns Array of items that pass the test
+     *
+     * @example
+     * ```typescript
+     * const darkThemes = registry.filter(theme => theme.isDark);
+     * ```
+     */
+    filter(predicate: (value: T, key: string) => boolean): T[];
+    /**
+     * Find an item in the registry
+     *
+     * Returns the first item that satisfies the provided predicate function.
+     * Returns undefined if no item passes the test.
+     *
+     * Time Complexity: O(n) worst case, O(1) best case
+     *
+     * @param predicate - Function to test each item (value, key) => boolean
+     * @returns First item that passes the test, or undefined
+     *
+     * @example
+     * ```typescript
+     * const defaultTheme = registry.find(theme => theme.isDefault);
+     * ```
+     */
+    find(predicate: (value: T, key: string) => boolean): T | undefined;
+}
+
+/**
+ * @fileoverview Facade interfaces
+ *
+ * Defines the interfaces for the Facade pattern implementation.
+ * Facades provide a static interface to services resolved from the DI container.
+ *
+ * @module @abdokouta/react-support
+ * @category Facades
+ */
+/**
+ * Application interface for facade resolution
+ *
+ * This interface represents the minimal contract that an application/container
+ * must implement to work with facades. It mirrors the Laravel Application contract.
+ */
+interface FacadeApplication {
+    /**
+     * Resolve a service from the container
+     *
+     * @param abstract - Service identifier (string, symbol, or class)
+     * @returns The resolved service instance
+     */
+    get<T>(abstract: string | symbol | (new (...args: unknown[]) => T)): T;
+    /**
+     * Check if a service has been resolved
+     *
+     * @param abstract - Service identifier
+     * @returns True if the service has been resolved
+     */
+    resolved?(abstract: string | symbol): boolean;
+    /**
+     * Register a callback to run after a service is resolved
+     *
+     * @param abstract - Service identifier
+     * @param callback - Callback to run after resolution
+     */
+    afterResolving?(abstract: string | symbol, callback: (service: unknown, app: FacadeApplication) => void): void;
+    /**
+     * Bind an instance to the container
+     *
+     * @param abstract - Service identifier
+     * @param instance - Instance to bind
+     */
+    instance?(abstract: string | symbol, instance: unknown): void;
+}
+/**
+ * Fake interface for testing
+ *
+ * Facades can be swapped with fakes for testing purposes.
+ * Any object implementing this interface is considered a fake.
+ */
+interface Fake {
+    /**
+     * Marker to identify fake instances
+     */
+    readonly __isFake: true;
+}
+/**
+ * Check if an object is a Fake
+ *
+ * @param obj - Object to check
+ * @returns True if the object is a Fake
+ */
+declare function isFake(obj: unknown): obj is Fake;
+
+/**
+ * @fileoverview Base Facade implementation
+ *
+ * This file provides the base Facade class that enables static access to
+ * services resolved from the DI container. Inspired by Laravel's Facade pattern.
+ *
+ * Uses @abdokouta/react-di's getModuleContainer to resolve services,
+ * enabling facades to work outside of React components.
+ *
+ * Key Features:
+ * - Static interface to container-resolved services
+ * - Instance caching for performance
+ * - Hot-swapping for testing
+ * - Fake detection for test assertions
+ * - Works outside React components
+ *
+ * @module @abdokouta/react-support
+ * @category Facades
+ */
+
+/**
+ * Base Facade class
+ *
+ * Provides a static interface to services resolved from the DI container.
+ * Subclasses must implement `getFacadeAccessor()` to specify which service
+ * the facade represents.
+ *
+ * @example
+ * ```typescript
+ * import { Facade } from '@abdokouta/react-support';
+ * import { LoggerService } from './logger.service';
+ * import { AppModule } from './app.module';
+ *
+ * class Log extends Facade {
+ *   protected static getFacadeAccessor(): ServiceIdentifier {
+ *     return LoggerService;
+ *   }
+ * }
+ *
+ * // Set the module once at app bootstrap
+ * Facade.setFacadeModule(AppModule);
+ *
+ * // Use the facade statically anywhere
+ * Log.info('Hello, world!');
+ * Log.error('Something went wrong');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Swap with a fake for testing
+ * const fakeLogs: string[] = [];
+ * const fakeLogger = {
+ *   __isFake: true as const,
+ *   info: (msg: string) => fakeLogs.push(msg),
+ *   error: (msg: string) => fakeLogs.push(msg),
+ * };
+ *
+ * Log.swap(fakeLogger);
+ * Log.info('Test message');
+ * expect(fakeLogs).toContain('Test message');
+ * ```
+ */
+declare abstract class Facade {
+    /**
+     * The root module class for resolving services
+     */
+    protected static moduleClass: Newable | null;
+    /**
+     * The module container instance (cached)
+     */
+    protected static container: ModuleContainer | null;
+    /**
+     * The resolved object instances
+     *
+     * Caches resolved instances by their accessor key for performance.
+     */
+    protected static resolvedInstance: Map<string | symbol, unknown>;
+    /**
+     * Indicates if the resolved instance should be cached
+     *
+     * Set to false in subclasses to always resolve fresh instances.
+     */
+    protected static cached: boolean;
+    /**
+     * Hotswap the underlying instance behind the facade
+     *
+     * Useful for testing - swap the real service with a mock or fake.
+     *
+     * @param instance - Instance to swap in
+     *
+     * @example
+     * ```typescript
+     * // In tests
+     * const mockLogger = { info: vi.fn(), error: vi.fn() };
+     * Log.swap(mockLogger);
+     *
+     * // Now Log.info() calls mockLogger.info()
+     * Log.info('test');
+     * expect(mockLogger.info).toHaveBeenCalledWith('test');
+     * ```
+     */
+    static swap(instance: unknown): void;
+    /**
+     * Determines whether a "fake" has been set as the facade instance
+     *
+     * @returns True if the current instance is a Fake
+     *
+     * @example
+     * ```typescript
+     * if (Log.isFake()) {
+     *   console.log('Using fake logger');
+     * }
+     * ```
+     */
+    static isFake(): boolean;
+    /**
+     * Get the root object behind the facade
+     *
+     * Resolves and returns the actual service instance.
+     *
+     * @returns The resolved service instance
+     */
+    static getFacadeRoot<T = unknown>(): T;
+    /**
+     * Get the registered name of the component
+     *
+     * Subclasses MUST override this method to specify which service
+     * the facade represents.
+     *
+     * @returns Service identifier (string, symbol, or class)
+     * @throws Error if not implemented
+     *
+     * @example
+     * ```typescript
+     * class Log extends Facade {
+     *   protected static getFacadeAccessor(): ServiceIdentifier {
+     *     return LoggerService; // or 'logger' string token
+     *   }
+     * }
+     * ```
+     */
+    protected static getFacadeAccessor(): ServiceIdentifier;
+    /**
+     * Get a consistent key for the accessor
+     */
+    protected static getAccessorKey(accessor: ServiceIdentifier): string | symbol;
+    /**
+     * Resolve the facade root instance from the container
+     *
+     * @param identifier - Service identifier
+     * @returns Resolved service instance
+     */
+    protected static resolveFacadeInstance<T>(identifier: ServiceIdentifier<T>): T;
+    /**
+     * Get the module container
+     *
+     * @returns The module container instance
+     */
+    protected static getContainer(): ModuleContainer | null;
+    /**
+     * Clear a resolved facade instance
+     *
+     * @param name - Service identifier to clear (defaults to this facade's accessor)
+     */
+    static clearResolvedInstance(name?: string | symbol): void;
+    /**
+     * Clear all resolved instances
+     *
+     * Useful for test cleanup.
+     */
+    static clearResolvedInstances(): void;
+    /**
+     * Get the module class
+     *
+     * @returns The module class
+     */
+    static getFacadeModule(): Newable | null;
+    /**
+     * Set the module class for facade resolution
+     *
+     * Must be called during application bootstrap to enable facades.
+     * Call this AFTER Inversiland.run() or Container.configure().build().
+     *
+     * @param module - The root module class
+     *
+     * @example
+     * ```typescript
+     * // In your app bootstrap (main.tsx)
+     * import { Facade } from '@abdokouta/react-support';
+     * import { Container, ContainerProvider } from '@abdokouta/react-di';
+     * import { AppModule } from './app.module';
+     *
+     * // Initialize container
+     * Container.configure().withModule(AppModule).withDefaults().build();
+     *
+     * // Set facade module
+     * Facade.setFacadeModule(AppModule);
+     *
+     * // Now facades work anywhere
+     * ReactDOM.createRoot(document.getElementById("root")!).render(
+     *   <ContainerProvider module={AppModule}>
+     *     <App />
+     *   </ContainerProvider>
+     * );
+     * ```
+     */
+    static setFacadeModule(module: Newable | null): void;
+    /**
+     * Set the container directly (alternative to setFacadeModule)
+     *
+     * @param container - The module container instance
+     */
+    static setFacadeContainer(container: ModuleContainer | null): void;
+    /**
+     * @deprecated Use setFacadeModule instead
+     */
+    static setFacadeApplication(app: FacadeApplication | null): void;
+    /**
+     * @deprecated Use getFacadeModule instead
+     */
+    static getFacadeApplication(): FacadeApplication | null;
+}
+
+/**
+ * @fileoverview Facade factory with Proxy support
+ *
+ * Creates facades with automatic method forwarding using JavaScript Proxy.
+ * This enables the Laravel-style `Facade::method()` pattern in TypeScript.
+ *
+ * @module @abdokouta/react-support
+ * @category Facades
+ */
+
+/**
+ * Facade class type with static methods and proxied service methods
+ */
+type FacadeClass<T> = typeof Facade & {
+    getFacadeRoot<R = T>(): R;
+} & {
+    [K in keyof T]: T[K];
+};
+/**
+ * Options for creating a facade
+ */
+interface CreateFacadeOptions<T> {
+    /**
+     * Service identifier (string token, symbol, or class)
+     */
+    accessor: ServiceIdentifier<T>;
+    /**
+     * Whether to cache the resolved instance
+     * @default true
+     */
+    cached?: boolean;
+}
+/**
+ * Create a facade for a service
+ *
+ * Creates a Proxy-based facade that forwards all method calls to the
+ * resolved service instance. This enables the Laravel-style pattern
+ * where you can call methods directly on the facade class.
+ *
+ * @param options - Facade configuration
+ * @returns Proxied facade class
+ *
+ * @example
+ * ```typescript
+ * // Define your service interface
+ * interface ILogger {
+ *   info(message: string): void;
+ *   error(message: string): void;
+ *   debug(message: string): void;
+ * }
+ *
+ * // Create the facade
+ * const Log = createFacade<ILogger>({
+ *   accessor: 'logger', // or LoggerService class
+ * });
+ *
+ * // Set module at bootstrap
+ * Facade.setFacadeModule(AppModule);
+ *
+ * // Use it statically
+ * Log.info('Hello!');
+ * Log.error('Oops!');
+ * ```
+ */
+declare function createFacade<T extends object>(options: CreateFacadeOptions<T>): FacadeClass<T>;
+/**
+ * Create a typed facade class (without proxy)
+ *
+ * @param accessor - Service identifier
+ * @returns Facade class constructor
+ */
+declare function createFacadeClass<T>(accessor: ServiceIdentifier<T>): typeof Facade;
+/**
+ * Get container from a module class
+ *
+ * @param moduleClass - The module class
+ * @returns ModuleContainer instance
+ */
+declare function getContainerFromModule(moduleClass: Newable): ModuleContainer;
+
+export { BaseRegistry, type BaseRegistryOptions, Collection$1 as Collection, type CreateFacadeOptions, Facade, type FacadeApplication, type FacadeClass, type Fake, MapCollection, SetCollection, Str, type ValidationResult, collect, collectMap, collectSet, createFacade, createFacadeClass, getContainerFromModule, isFake };