/**
 * Caches the result of a method until the promise is resolved.
 * @param {any} _target - The target object.
 * @param {string} propertyKey - The name of the method.
 * @param {PropertyDescriptor} descriptor - The property descriptor.
 * @returns {PropertyDescriptor} The modified property descriptor.
 * @example
 * class Example {
 *   @CacheUntilResolved
 *   async fetchData() {
 *     // ...fetch data...
 *   }
 * }
 */
export declare function CacheUntilResolved(_target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
/**
 * Debounces the method call by the specified delay.
 * @param {number} [delay=300] - The delay in milliseconds.
 * @returns {Function} A function that modifies the property descriptor.
 * @example
 * class Example {
 *   @Debounce(500)
 *   onResize() {
 *     // ...handle resize...
 *   }
 * }
 */
export declare function Debounce(delay?: number): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
/**
 * Makes the arguments of a method immutable.
 * @param {any} _target - The target object.
 * @param {string | symbol} _propertyKey - The name of the method.
 * @param {PropertyDescriptor} descriptor - The property descriptor.
 * @returns {PropertyDescriptor} The modified property descriptor.
 * @example
 * class Example {
 *   @ImmutableArgs
 *   updateData(data: any) {
 *     // ...update data...
 *   }
 * }
 */
export declare function ImmutableArgs(_target: any, _propertyKey: string | symbol, descriptor: PropertyDescriptor): PropertyDescriptor;
/**
 * Memoizes the result of a method.
 * @param {any} _target - The target object.
 * @param {string} _key - The name of the method.
 * @param {PropertyDescriptor} descriptor - The property descriptor.
 * @returns {PropertyDescriptor} The modified property descriptor.
 * @example
 * class Example {
 *   @Memoize
 *   computeValue(x: number) {
 *     return x * 2;
 *   }
 * }
 */
export declare function Memoize(_target: any, _key: string, descriptor: PropertyDescriptor): void;
/**
 * Memoizes the result of an async method.
 * @param {any} _target - The target object.
 * @param {string} _propertyKey - The name of the method.
 * @param {PropertyDescriptor} descriptor - The property descriptor.
 * @returns {PropertyDescriptor} The modified property descriptor.
 * @example
 * class Example {
 *   @MemoizeAsync
 *   async fetchData() {
 *     // ...fetch data...
 *   }
 * }
 */
export declare function MemoizeAsync(_target: any, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
/**
 * Queues the method call as a microtask.
 * @param {any} _target - The target object.
 * @param {string} _key - The name of the method.
 * @param {PropertyDescriptor} descriptor - The property descriptor.
 * @returns {PropertyDescriptor} The modified property descriptor.
 * @example
 * class Example {
 *   @QueueTask
 *   processTask() {
 *     // ...process task...
 *   }
 * }
 */
export declare function QueueTask(_target: unknown, _key: string, descriptor: PropertyDescriptor): void;
/**
 * Throttles the method call by the specified delay.
 * @param {number} [delay=300] - The delay in milliseconds.
 * @returns {Function} A function that modifies the property descriptor.
 * @example
 * class Example {
 *   @Throttle(500)
 *   onScroll() {
 *     // ...handle scroll...
 *   }
 * }
 */
export declare function Throttle(delay?: number): (_target: any, _propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
/**
 * AsyncSingleExecution decorator ensures that multiple concurrent calls to an async function
 * with the same arguments will return the same promise instance until it resolves.
 * Once resolved, subsequent calls will trigger a new execution.
 * @param _target
 * @param _propertyKey
 * @param descriptor
 * @returns {Function} A function that modifies the property descriptor.
 * @example
 * ```typescript
 * import { AsyncSingleExecution } from './functionDecorators';
 *
 * class Example {
 *   @AsyncSingleExecution
 *   async fetchData(id: number) {
 *     console.log('Fetching data for', id);
 *     return new Promise(resolve => setTimeout(() => resolve(id), 1000));
 *   }
 * }
 *
 * const instance = new Example();
 * const promise1 = instance.fetchData(1);
 * const promise2 = instance.fetchData(1);
 *
 * console.log(promise1 === promise2); // true
 * ```
 *
 * // Output:
 * // Fetching data for 1 (only logged once)
 * ```
 */
export declare function AsyncSingleExecution(_target: any, _propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
/**
 * Retries an async method a specified number of times with a delay between attempts.
 * @param {number} [retries=3] - The number of retry attempts.
 * @param {number} [interval=2000] - The delay in milliseconds between retries.
 * @param {boolean} [reThrowException=true] - Whether to rethrow the exception after all retries fail.
 * @returns {MethodDecorator} A method decorator that modifies the property descriptor.
 * @example
 * class Example {
 *   @RetryAsync(3, 1000, true)
 *   async fetchData() {
 *     console.log('Attempting to fetch data...');
 *     if (Math.random() < 0.7) {
 *       throw new Error('Fetch failed');
 *     }
 *     return 'Data fetched successfully';
 *   }
 * }
 *
 * const instance = new Example();
 * instance.fetchData().then(console.log).catch(console.error);
 *
 * // Output (example):
 * // Attempting to fetch data...
 * // Attempting to fetch data...
 * // Attempting to fetch data...
 * // Error: Fetch failed
 */
export declare function RetryAsync(retries?: number, interval?: number, reThrowException?: boolean): MethodDecorator;
/**
 * Memoizes the result of a function with a single primitive argument or no arguments.
 * Only caches results for functions that take exactly one primitive argument (string, number, boolean, symbol, null, or undefined)
 * or no arguments at all. Uses a simple object as the cache.
 * @param _target
 * @param _propertyKey
 * @param descriptor
 * @example
 * // Single primitive argument
 * class Example {
 *   @MemoizeSingleArgPrimitive
 *   double(x: number) {
 *     return x * 2;
 *   }
 * }
 * const ex = new Example();
 * ex.double(2); // Calls original, returns 4
 * ex.double(2); // Returns cached result, 4
 * @example
 * // No arguments
 * class ExampleNoArg {
 *   @MemoizeSingleArgPrimitive
 *   getRandom() {
 *     return Math.random();
 *   }
 * }
 * const ex2 = new ExampleNoArg();
 * ex2.getRandom(); // Calls original, returns a value
 * ex2.getRandom(); // Returns cached value
 * @example
 * // Not cached for non-primitive or multiple arguments
 * class ExampleObj {
 *   @MemoizeSingleArgPrimitive
 *   sum(obj: { x: number }) {
 *     return obj.x + 1;
 *   }
 * }
 * const ex3 = new ExampleObj();
 * ex3.sum({ x: 1 }); // Calls original
 * ex3.sum({ x: 1 }); // Calls original again (not cached)
 */
export declare function MemoizeSingleArgPrimitive<T extends string | number | boolean | symbol | null | undefined, R>(_target: any, _propertyKey: string, descriptor: TypedPropertyDescriptor<(...args: any[]) => R>): TypedPropertyDescriptor<(...args: any[]) => R>;
