Async and Generator Helpers

/**
 * Converts generator functions to async functions
 * @param fn - Generator function to convert
 * @returns Function that returns a Promise
 */
function asyncToGenerator(fn: GeneratorFunction): (...args: any[]) => Promise<any>;

import _asyncToGenerator from '@babel/runtime/helpers/esm/asyncToGenerator';
import '@babel/runtime/regenerator';

// Used by Babel for: async function example() { return await fetch('/api'); }
const example = _asyncToGenerator(function* () {
  return yield fetch('/api');
});

/**
 * Creates async iterators
 * @param iterable - Object to create async iterator from
 * @returns Async iterator
 */
function asyncIterator(iterable: any): AsyncIterator<any>;

/**
 * Delegates to async generators
 * @param inner - Inner async iterator to delegate to
 * @param awaitWrap - Function to wrap awaited values
 * @returns Delegating async iterator
 */
function asyncGeneratorDelegate(inner: AsyncIterator<any>, awaitWrap: Function): AsyncIterator<any>;

/**
 * Awaits async generator values
 * @param value - Value to await from async generator
 * @returns Promise resolving to awaited value
 */
function awaitAsyncGenerator(value: any): Promise<any>;

/**
 * Wraps functions as async generators
 * @param fn - Function to wrap as async generator
 * @returns Async generator function
 */
function wrapAsyncGenerator(fn: Function): AsyncGeneratorFunction;

/**
 * Core regenerator functionality
 * @returns Regenerator runtime object
 */
function regenerator(): any;

/**
 * Complete regenerator runtime
 * @returns Full regenerator runtime with all generator capabilities
 */
function regeneratorRuntime(): RegeneratorRuntime;

interface RegeneratorRuntime {
  wrap: (fn: GeneratorFunction, outerFn?: Function, self?: any, tryLocsList?: any[]) => Generator<any, any, any>;
  isGeneratorFunction: (genFun: any) => boolean;
  mark: (genFun: GeneratorFunction) => GeneratorFunction;
  awrap: (arg: any) => AwaitArgument;
  async: (innerFn: GeneratorFunction, outerFn?: Function, self?: any, tryLocsList?: any[]) => Promise<any>;
  keys: (object: any) => string[];
  values: (iterable: any) => any[];
}

// Import regenerator runtime globally
import '@babel/runtime/regenerator';

// Now generator functions and async/await work
function* myGenerator() {
  yield 1;
  yield 2;
  return 3;
}

async function myAsyncFunction() {
  const result = await Promise.resolve('hello');
  return result;
}

/**
 * Async generator support
 * @param innerFn - Inner generator function
 * @param outerFn - Outer function context
 * @param self - This binding
 * @param tryLocsList - Try/catch location list
 * @returns Promise resolving to generator result
 */
function regeneratorAsync(innerFn: GeneratorFunction, outerFn?: Function, self?: any, tryLocsList?: any[]): Promise<any>;

/**
 * Async generator creation
 * @param innerFn - Inner generator function
 * @param outerFn - Outer function context
 * @param self - This binding
 * @returns Async generator
 */
function regeneratorAsyncGen(innerFn: GeneratorFunction, outerFn?: Function, self?: any): AsyncGenerator<any, any, any>;

/**
 * Generator key iteration
 * @param object - Object to iterate keys
 * @returns Generator yielding object keys
 */
function regeneratorKeys(object: any): Generator<string, void, unknown>;

/**
 * Generator value iteration
 * @param iterable - Iterable to get values from
 * @returns Generator yielding values
 */
function regeneratorValues(iterable: any): Generator<any, void, unknown>;

/**
 * Skips first generator next()
 * @param fn - Generator function
 * @returns Generator with first next() skipped
 */
function skipFirstGeneratorNext(fn: GeneratorFunction): Generator<any, any, any>;

/**
 * Wrapper for awaited values
 * @param value - Value to wrap for awaiting
 * @returns Wrapped await value
 */
function AwaitValue(value: any): AwaitArgument;

interface AwaitArgument {
  __await: any;
}

/**
 * Handles generator yield overloading
 * @param value - Value being yielded
 * @returns Processed yield value
 */
function OverloadYield(value: any): any;

// Global regenerator setup
require('@babel/runtime/regenerator');

// Or ES module import
import '@babel/runtime/regenerator';

// Generator function types
type GeneratorFunction = (...args: any[]) => Generator<any, any, any>;
type AsyncGeneratorFunction = (...args: any[]) => AsyncGenerator<any, any, any>;

// Generator interfaces
interface Generator<T, TReturn, TNext> {
  next(value?: TNext): IteratorResult<T>;
  return(value?: TReturn): IteratorResult<T>;
  throw(e?: any): IteratorResult<T>;
  [Symbol.iterator](): Generator<T, TReturn, TNext>;
}

interface AsyncGenerator<T, TReturn, TNext> {
  next(value?: TNext): Promise<IteratorResult<T>>;
  return(value?: TReturn): Promise<IteratorResult<T>>;
  throw(e?: any): Promise<IteratorResult<T>>;
  [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
}

// Iterator result
interface IteratorResult<T> {
  done: boolean;
  value: T;
}

// Async iterator
interface AsyncIterator<T> {
  next(value?: any): Promise<IteratorResult<T>>;
  return?(value?: any): Promise<IteratorResult<T>>;
  throw?(e?: any): Promise<IteratorResult<T>>;
}

// Await wrapper
interface AwaitArgument {
  __await: any;
}

// Regenerator runtime interface
interface RegeneratorRuntime {
  wrap(fn: GeneratorFunction, outerFn?: Function, self?: any, tryLocsList?: any[]): Generator<any, any, any>;
  isGeneratorFunction(genFun: any): boolean;
  mark(genFun: GeneratorFunction): GeneratorFunction;
  awrap(arg: any): AwaitArgument;
  async(innerFn: GeneratorFunction, outerFn?: Function, self?: any, tryLocsList?: any[]): Promise<any>;
  keys(object: any): string[];
  values(iterable: any): any[];
}