export { Bounded, Coercible, Copyable, Defaultable, EQ_ORD, Enum, Eq, Floating, Fractional, GT, Group, Identifiable, Integral, LT, Monoid, Numeric, Ord, Ordering, ParCombine, ParCombineBuilder, ParseResult, Parseable, Printable, Reducible, Searchable, Semigroup, Sized, Splittable, Zippable, bigIntToNumber, booleanToNumber, boundedBigInt, boundedBoolean, boundedNumber, boundedString, clampWith, copyableArray, copyableBigInt, copyableBoolean, copyableDate, copyableMap, copyableNumber, copyableSet, copyableString, dateToNumber, defaultArray, defaultBigInt, defaultBoolean, defaultDate, defaultMap, defaultNumber, defaultSet, defaultString, enumBoolean, enumNumber, enumString, eqArray, eqBigInt, eqBoolean, eqBy, eqDate, eqNumber, eqStrict, eqString, floatingNumber, fractionalNumber, fromInt, fromInteger, gcdWith, getParCombine, getParCombineBuilder, groupBigInt, groupNumber, integralBigInt, integralNumber, inverseLerpWith, lcmWith, lerpWith, makeEq, makeOrd, max, maxBy, min, minBy, monoidArray, monoidBigInt, monoidNumber, monoidString, numberToBigInt, numberToBoolean, numberToDate, numberToString, numericBigInt, numericNumber, ordArray, ordBigInt, ordBoolean, ordBy, ordDate, ordNumber, ordString, parCombineArray, parCombineAsyncIterable, parCombineIterable, parCombinePromise, parseableBigInt, parseableBoolean, parseableNumber, pow, powFrac, printableBoolean, printableDate, printableNumber, printableString, product, registerParCombine, reverseOrd, semigroupArray, semigroupBigInt, semigroupNumber, semigroupString, sizedArray, sizedMap, sizedSet, sizedString, stringToBoolean, stringToNumber, sum } from './typeclasses/index.js';
export { ArrayExt, BooleanExt, DateExt, FunctionExt, MapExt, NumberExt, ObjectExt, PromiseExt, RetryOptions, SetExt, SettledResult, StringExt, absurd, addDays, addHours, addMilliseconds, addMinutes, addMonths, addSeconds, addWeeks, addYears, after, allFulfilled, arrayGroupBy, arrayToMap, before, boolToInt, camelCase, capitalize, ceilTo, chunk, clamp, clampDate, compact, complement, constant, converge, createDeferred, curry2, curry3, dayOfYear, daysInMonth, daysInYear, debounce, deepMerge, defaults, delay, diffInDays, diffInHours, diffInMilliseconds, diffInMinutes, diffInMonths, diffInSeconds, diffInWeeks, diffInYears, digitSum, digits, divisors, downTo, dropWhile, eachDay, endOfDay, endOfMonth, endOfYear, factorial, fallbackTo, fibonacci, filterConcurrent, filterMapKeys, filterMapValues, flatten, flip, floorTo, formatDate, formatDateTime, formatISO, formatRelative, formatTime, gcd, identity, intersperse, inverseLerp, invert, isAfter, isBefore, isBetween, isBetweenDates, isBlank, isEven, isFiniteNum, isInteger, isLeapYear, isMultipleOf, isNaN_, isNegative, isOdd, isPerfectSquare, isPositive, isPowerOfTwo, isPrime, isSameDay, isSameMonth, isSameYear, isToday, isTomorrow, isWeekday, isWeekend, isYesterday, isZero, isqrt, juxt, kebabCase, lazy, lcm, lerp, mapConcurrent, mapKeys, mapValues, maxDate, memo, memoize, memoizeWeak, minDate, nCr, nPr, negate, noop, objectToMap, omit, on, once, padStart, parseIntSafe, partial, partial2, partition, pascalCase, pick, props, quarter, randomFloat, randomInt, rangeTo, rangeUntil, recover, remap, retry, roundTo, saturatingAdd, saturatingSub, setDifference, setIntersection, setUnion, settle, shuffle, sleep, snakeCase, snap, sortBy, startOfDay, startOfMonth, startOfWeek, startOfYear, takeWhile, tap, tapError, throttle, timeout, timeoutOr, times, timesVoid, toBase, toBin, toCompact, toDuration, toFileSize, toHex, toOct, toOrdinal, toPercent, toRoman, toWords, truncTo, truncate, tryCatch, tupled, tupled3, uncurry2, uncurry3, unique, uniqueBy, untupled, upTo, weekOfYear, words, wrappingAdd, wrappingSub, zip, zipWith } from './extensions/index.js';
export { Pair, Range, RangeExt, Triple, TupleExt, bimap, both, curryPair, eqPair, eqRange, eqTriple, fst, mapFst, mapSnd, ordPair, ordRange, ordTriple, pair, pairToArray, range, rangeBy, rangeContains, rangeFilter, rangeFirst, rangeForEach, rangeInclusive, rangeIsEmpty, rangeIterator, rangeLast, rangeMap, rangeReduce, rangeReversed, rangeSize, rangeToArray, snd, swap, triple, tripleFirst, tripleMap, tripleSecond, tripleThird, tripleToArray, uncurryPair, unzipPairs, zipToPairs } from './data/index.js';
export { B as BindStep, C as ComprehensionStep, G as GuardStep, M as MapStep, c as collectReferencedIdentifiers, a as createArrowFn, b as createIIFE, d as createMethodCall, e as extractReturnExpr, i as inferTypeConstructor } from './comprehension-utils-CrcEKA_W.js';
export { GuardArm, P, isType, letYieldMacro, match, matchGuard, matchGuardMacro, matchLiteral, matchLiteralMacro, matchMacro, otherwise, parYieldMacro, registerLetYield, registerParYield, registerStdInstances, registerStdInstancesMacro, when } from './macros/index.js';
import { FlatMap } from './typeclasses/flatmap.js';
export { flatMapArray, flatMapAsyncIterable, flatMapIterable, flatMapPromise, getFlatMap, hasFlatMap, registerFlatMap } from './typeclasses/flatmap.js';
import '@typesugar/core';
import 'typescript';
import '@typesugar/macros';

/**
 * Std Specialization Support
 *
 * Re-exports std's FlatMap instances for use with the `specialize()` macro.
 * The instances are registered with the core specialization registry at
 * compile time (in the transformer), enabling zero-cost abstraction for
 * generic FlatMap-polymorphic code.
 *
 * ## Usage
 *
 * Users can write generic code using the FlatMap interface and then
 * specialize it to eliminate dictionary passing:
 *
 * ```typescript
 * import { specialize } from "typemacro";
 * import { stdFlatMapArray, stdFlatMapPromise } from "@typesugar/std/specialize";
 *
 * // Generic function using FlatMap
 * function double<F>(F: FlatMap<F>, fa: Kind<F, number>): Kind<F, number> {
 *   return F.map(fa, x => x * 2);
 * }
 *
 * // Specialized versions — zero dictionary overhead
 * const doubleArray = specialize(double, stdFlatMapArray);
 * // Expands to: (fa: number[]) => fa.map(x => x * 2)
 *
 * const doublePromise = specialize(double, stdFlatMapPromise);
 * // Expands to: (fa: Promise<number>) => fa.then(x => x * 2)
 * ```
 *
 * ## Registered Instances
 *
 * The following instances are registered with the core specialization
 * registry and can be referenced by name with `specialize()`:
 *
 * - `stdFlatMapArray` / `flatMapArray` — FlatMap for Array<A>
 * - `stdFlatMapPromise` / `flatMapPromise` — FlatMap for Promise<A>
 * - `stdFlatMapIterable` / `flatMapIterable` — FlatMap for Iterable<A>
 * - `stdFlatMapAsyncIterable` / `flatMapAsyncIterable` — FlatMap for AsyncIterable<A>
 *
 * @module
 */

/**
 * FlatMap instance for Array — use with specialize() for zero-cost abstraction.
 *
 * @example
 * ```typescript
 * const doubleArray = specialize(double, stdFlatMapArray);
 * ```
 */
declare const stdFlatMapArray: FlatMap<unknown>;
/**
 * FlatMap instance for Promise — use with specialize() for zero-cost abstraction.
 *
 * @example
 * ```typescript
 * const doublePromise = specialize(double, stdFlatMapPromise);
 * ```
 */
declare const stdFlatMapPromise: FlatMap<unknown>;
/**
 * FlatMap instance for Iterable — use with specialize() for zero-cost abstraction.
 *
 * @example
 * ```typescript
 * const doubleIterable = specialize(double, stdFlatMapIterable);
 * ```
 */
declare const stdFlatMapIterable: FlatMap<unknown>;
/**
 * FlatMap instance for AsyncIterable — use with specialize() for zero-cost abstraction.
 *
 * @example
 * ```typescript
 * const doubleAsyncIterable = specialize(double, stdFlatMapAsyncIterable);
 * ```
 */
declare const stdFlatMapAsyncIterable: FlatMap<unknown>;
/**
 * Pre-specialized array map. Equivalent to `specialize((F, fa, f) => F.map(fa, f), stdFlatMapArray)`.
 *
 * This is a compile-time optimization hint — the actual specialization
 * happens when code using these helpers is transformed.
 */
declare function arrayMap<A, B>(fa: A[], f: (a: A) => B): B[];
/**
 * Pre-specialized array flatMap. Equivalent to `specialize((F, fa, f) => F.flatMap(fa, f), stdFlatMapArray)`.
 */
declare function arrayFlatMap<A, B>(fa: A[], f: (a: A) => B[]): B[];
/**
 * Pre-specialized promise map. Equivalent to `specialize((F, fa, f) => F.map(fa, f), stdFlatMapPromise)`.
 */
declare function promiseMap<A, B>(fa: Promise<A>, f: (a: A) => B): Promise<B>;
/**
 * Pre-specialized promise flatMap. Equivalent to `specialize((F, fa, f) => F.flatMap(fa, f), stdFlatMapPromise)`.
 */
declare function promiseFlatMap<A, B>(fa: Promise<A>, f: (a: A) => Promise<B>): Promise<B>;
/**
 * Pre-specialized iterable map — lazy evaluation.
 */
declare function iterableMap<A, B>(fa: Iterable<A>, f: (a: A) => B): Iterable<B>;
/**
 * Pre-specialized iterable flatMap — lazy evaluation.
 */
declare function iterableFlatMap<A, B>(fa: Iterable<A>, f: (a: A) => Iterable<B>): Iterable<B>;
/**
 * Pre-specialized async iterable map — lazy async evaluation.
 */
declare function asyncIterableMap<A, B>(fa: AsyncIterable<A>, f: (a: A) => B): AsyncIterable<B>;
/**
 * Pre-specialized async iterable flatMap — lazy async evaluation.
 */
declare function asyncIterableFlatMap<A, B>(fa: AsyncIterable<A>, f: (a: A) => AsyncIterable<B>): AsyncIterable<B>;

export { FlatMap, arrayFlatMap, arrayMap, asyncIterableFlatMap, asyncIterableMap, iterableFlatMap, iterableMap, promiseFlatMap, promiseMap, stdFlatMapArray, stdFlatMapAsyncIterable, stdFlatMapIterable, stdFlatMapPromise };
