import { describe, expectTypeOf, it } from 'vitest';
import * as compat from 'es-toolkit/compat';
import type * as lodash from 'lodash';

describe('es-toolkit/compat', () => {
  it('matches the type of lodash', () => {
    // array
    expectTypeOf(compat.castArray).toEqualTypeOf<typeof lodash.castArray>();
    expectTypeOf(compat.chunk).toEqualTypeOf<typeof lodash.chunk>();
    expectTypeOf(compat.compact).toEqualTypeOf<typeof lodash.compact>();
    expectTypeOf(compat.concat).toEqualTypeOf<typeof lodash.concat>();
    expectTypeOf(compat.countBy).toEqualTypeOf<typeof lodash.countBy>();
    expectTypeOf(compat.difference).toEqualTypeOf<typeof lodash.difference>();
    expectTypeOf(compat.differenceBy).toEqualTypeOf<typeof lodash.differenceBy>();
    expectTypeOf(compat.differenceWith).toEqualTypeOf<typeof lodash.differenceWith>();
    expectTypeOf(compat.drop).toEqualTypeOf<typeof lodash.drop>();
    expectTypeOf(compat.dropRight).toEqualTypeOf<typeof lodash.dropRight>();
    expectTypeOf(compat.dropRightWhile).toEqualTypeOf<typeof lodash.dropRightWhile>();
    expectTypeOf(compat.dropWhile).toEqualTypeOf<typeof lodash.dropWhile>();
    expectTypeOf(compat.each).toEqualTypeOf<typeof lodash.each>();
    expectTypeOf(compat.eachRight).toEqualTypeOf<typeof lodash.eachRight>();
    expectTypeOf(compat.every).toEqualTypeOf<typeof lodash.every>();
    expectTypeOf(compat.fill).toEqualTypeOf<typeof lodash.fill>();
    expectTypeOf(compat.filter).toEqualTypeOf<typeof lodash.filter>();
    expectTypeOf(compat.find).toEqualTypeOf<typeof lodash.find>();
    expectTypeOf(compat.findIndex).toEqualTypeOf<typeof lodash.findIndex>();
    expectTypeOf(compat.findLast).toEqualTypeOf<typeof lodash.findLast>();
    expectTypeOf(compat.findLastIndex).toEqualTypeOf<typeof lodash.findLastIndex>();
    expectTypeOf(compat.first).toEqualTypeOf<typeof lodash.first>();
    expectTypeOf(compat.flatMap).toEqualTypeOf<typeof lodash.flatMap>();
    expectTypeOf(compat.flatMapDeep).toEqualTypeOf<typeof lodash.flatMapDeep>();
    expectTypeOf(compat.flatMapDepth).toEqualTypeOf<typeof lodash.flatMapDepth>();
    expectTypeOf(compat.flatten).toEqualTypeOf<typeof lodash.flatten>();
    expectTypeOf(compat.flattenDeep).toEqualTypeOf<typeof lodash.flattenDeep>();
    expectTypeOf(compat.flattenDepth).toEqualTypeOf<typeof lodash.flattenDepth>();
    expectTypeOf(compat.forEach).toEqualTypeOf<typeof lodash.forEach>();
    expectTypeOf(compat.forEachRight).toEqualTypeOf<typeof lodash.forEachRight>();
    expectTypeOf(compat.groupBy).toEqualTypeOf<typeof lodash.groupBy>();
    expectTypeOf(compat.head).toEqualTypeOf<typeof lodash.head>();
    expectTypeOf(compat.includes).toEqualTypeOf<typeof lodash.includes>();
    expectTypeOf(compat.indexOf).toEqualTypeOf<typeof lodash.indexOf>();
    expectTypeOf(compat.initial).toEqualTypeOf<typeof lodash.initial>();
    expectTypeOf(compat.intersection).toEqualTypeOf<typeof lodash.intersection>();
    expectTypeOf(compat.intersectionBy).toEqualTypeOf<typeof lodash.intersectionBy>();
    expectTypeOf(compat.intersectionWith).toEqualTypeOf<typeof lodash.intersectionWith>();
    expectTypeOf(compat.invokeMap).toEqualTypeOf<typeof lodash.invokeMap>();
    expectTypeOf(compat.join).toEqualTypeOf<typeof lodash.join>();
    expectTypeOf(compat.keyBy).toEqualTypeOf<typeof lodash.keyBy>();
    expectTypeOf(compat.last).toEqualTypeOf<typeof lodash.last>();
    expectTypeOf(compat.lastIndexOf).toEqualTypeOf<typeof lodash.lastIndexOf>();
    // NOTE: expectTypeOf does not support checking complex overloaded map types
    // expectTypeOf(compat.map).toEqualTypeOf<typeof lodash.map>();
    expectTypeOf(compat.nth).toEqualTypeOf<typeof lodash.nth>();
    expectTypeOf(compat.orderBy).toEqualTypeOf<typeof lodash.orderBy>();
    expectTypeOf(compat.partition).toEqualTypeOf<typeof lodash.partition>();
    // NOTE: TypeScript doesn't support matching conditional types
    // expectTypeOf(compat.pull).toEqualTypeOf<typeof lodash.pull>();
    expectTypeOf(compat.pullAll).toEqualTypeOf<typeof lodash.pullAll>();
    // NOTE: TypeScript doesn't support matching conditional types
    // expectTypeOf(compat.pullAllBy).toEqualTypeOf<typeof lodash.pullAllBy>();
    expectTypeOf(compat.pullAllWith).toEqualTypeOf<typeof lodash.pullAllWith>();
    expectTypeOf(compat.pullAt).toEqualTypeOf<typeof lodash.pullAt>();
    expectTypeOf(compat.reduce).toEqualTypeOf<typeof lodash.reduce>();
    expectTypeOf(compat.reduceRight).toEqualTypeOf<typeof lodash.reduceRight>();
    expectTypeOf(compat.reject).toEqualTypeOf<typeof lodash.reject>();
    expectTypeOf(compat.remove).toEqualTypeOf<typeof lodash.remove>();
    expectTypeOf(compat.reverse).toEqualTypeOf<typeof lodash.reverse>();
    expectTypeOf(compat.sample).toEqualTypeOf<typeof lodash.sample>();
    expectTypeOf(compat.sampleSize).toEqualTypeOf<typeof lodash.sampleSize>();
    expectTypeOf(compat.shuffle).toEqualTypeOf<typeof lodash.shuffle>();
    expectTypeOf(compat.size).toEqualTypeOf<typeof lodash.size>();
    expectTypeOf(compat.slice).toEqualTypeOf<typeof lodash.slice>();
    expectTypeOf(compat.some).toEqualTypeOf<typeof lodash.some>();
    expectTypeOf(compat.sortBy).toEqualTypeOf<typeof lodash.sortBy>();
    expectTypeOf(compat.sortedIndex).toEqualTypeOf<typeof lodash.sortedIndex>();
    expectTypeOf(compat.sortedIndexBy).toEqualTypeOf<typeof lodash.sortedIndexBy>();
    expectTypeOf(compat.sortedIndexOf).toEqualTypeOf<typeof lodash.sortedIndexOf>();
    expectTypeOf(compat.sortedLastIndex).toEqualTypeOf<typeof lodash.sortedLastIndex>();
    expectTypeOf(compat.sortedLastIndexBy).toEqualTypeOf<typeof lodash.sortedLastIndexBy>();
    expectTypeOf(compat.sortedLastIndexOf).toEqualTypeOf<typeof lodash.sortedLastIndexOf>();
    expectTypeOf(compat.tail).toEqualTypeOf<typeof lodash.tail>();
    expectTypeOf(compat.take).toEqualTypeOf<typeof lodash.take>();
    expectTypeOf(compat.takeRight).toEqualTypeOf<typeof lodash.takeRight>();
    expectTypeOf(compat.takeRightWhile).toEqualTypeOf<typeof lodash.takeRightWhile>();
    expectTypeOf(compat.takeWhile).toEqualTypeOf<typeof lodash.takeWhile>();
    expectTypeOf(compat.union).toEqualTypeOf<typeof lodash.union>();
    expectTypeOf(compat.unionBy).toEqualTypeOf<typeof lodash.unionBy>();
    expectTypeOf(compat.unionWith).toEqualTypeOf<typeof lodash.unionWith>();
    expectTypeOf(compat.uniq).toEqualTypeOf<typeof lodash.uniq>();
    expectTypeOf(compat.uniqBy).toEqualTypeOf<typeof lodash.uniqBy>();
    expectTypeOf(compat.uniqWith).toEqualTypeOf<typeof lodash.uniqWith>();
    expectTypeOf(compat.unzip).toEqualTypeOf<typeof lodash.unzip>();
    expectTypeOf(compat.unzipWith).toEqualTypeOf<typeof lodash.unzipWith>();
    expectTypeOf(compat.without).toEqualTypeOf<typeof lodash.without>();
    expectTypeOf(compat.xor).toEqualTypeOf<typeof lodash.xor>();
    expectTypeOf(compat.xorBy).toEqualTypeOf<typeof lodash.xorBy>();
    expectTypeOf(compat.xorWith).toEqualTypeOf<typeof lodash.xorWith>();
    expectTypeOf(compat.zip).toEqualTypeOf<typeof lodash.zip>();
    expectTypeOf(compat.zipObject).toEqualTypeOf<typeof lodash.zipObject>();
    expectTypeOf(compat.zipObjectDeep).toEqualTypeOf<typeof lodash.zipObjectDeep>();
    expectTypeOf(compat.zipWith).toEqualTypeOf<typeof lodash.zipWith>();

    // function
    expectTypeOf(compat.after).toEqualTypeOf<typeof lodash.after>();
    expectTypeOf(compat.ary).toEqualTypeOf<typeof lodash.ary>();
    expectTypeOf(compat.attempt).toEqualTypeOf<typeof lodash.attempt>();
    expectTypeOf(compat.before).toEqualTypeOf<typeof lodash.before>();
    // NOTE: expectTypeOf does not support checking custom FunctionBind/Curry types
    // expectTypeOf(compat.bind).toEqualTypeOf<typeof lodash.bind>();
    // expectTypeOf(compat.bindKey).toEqualTypeOf<typeof lodash.bindKey>();
    // expectTypeOf(compat.curry).toEqualTypeOf<typeof lodash.curry>();
    // expectTypeOf(compat.curryRight).toEqualTypeOf<typeof lodash.curryRight>();
    expectTypeOf(compat.debounce).toEqualTypeOf<typeof lodash.debounce>();
    expectTypeOf(compat.defer).toEqualTypeOf<typeof lodash.defer>();
    expectTypeOf(compat.delay).toEqualTypeOf<typeof lodash.delay>();
    expectTypeOf(compat.flip).toEqualTypeOf<typeof lodash.flip>();
    expectTypeOf(compat.flow).toEqualTypeOf<typeof lodash.flow>();
    expectTypeOf(compat.flowRight).toEqualTypeOf<typeof lodash.flowRight>();
    expectTypeOf(compat.identity).toEqualTypeOf<typeof lodash.identity>();
    expectTypeOf(compat.memoize).toEqualTypeOf<typeof lodash.memoize>();
    expectTypeOf(compat.negate).toEqualTypeOf<typeof lodash.negate>();
    expectTypeOf(compat.noop).toEqualTypeOf<typeof lodash.noop>();
    expectTypeOf(compat.nthArg).toEqualTypeOf<typeof lodash.nthArg>();
    expectTypeOf(compat.once).toEqualTypeOf<typeof lodash.once>();
    expectTypeOf(compat.overArgs).toEqualTypeOf<typeof lodash.overArgs>();
    // NOTE: expectTypeOf does not support checking custom Partial types
    // expectTypeOf(compat.partial).toEqualTypeOf<typeof lodash.partial>();
    // expectTypeOf(compat.partialRight).toEqualTypeOf<typeof lodash.partialRight>();
    expectTypeOf(compat.rearg).toEqualTypeOf<typeof lodash.rearg>();
    expectTypeOf(compat.rest).toEqualTypeOf<typeof lodash.rest>();
    expectTypeOf(compat.spread).toEqualTypeOf<typeof lodash.spread>();
    expectTypeOf(compat.throttle).toEqualTypeOf<typeof lodash.throttle>();
    expectTypeOf(compat.unary).toEqualTypeOf<typeof lodash.unary>();
    expectTypeOf(compat.wrap).toEqualTypeOf<typeof lodash.wrap>();

    // math
    expectTypeOf(compat.add).toEqualTypeOf<typeof lodash.add>();
    expectTypeOf(compat.ceil).toEqualTypeOf<typeof lodash.ceil>();
    expectTypeOf(compat.clamp).toEqualTypeOf<typeof lodash.clamp>();
    expectTypeOf(compat.divide).toEqualTypeOf<typeof lodash.divide>();
    expectTypeOf(compat.floor).toEqualTypeOf<typeof lodash.floor>();
    expectTypeOf(compat.inRange).toEqualTypeOf<typeof lodash.inRange>();
    expectTypeOf(compat.max).toEqualTypeOf<typeof lodash.max>();
    expectTypeOf(compat.maxBy).toEqualTypeOf<typeof lodash.maxBy>();
    expectTypeOf(compat.mean).toEqualTypeOf<typeof lodash.mean>();
    expectTypeOf(compat.meanBy).toEqualTypeOf<typeof lodash.meanBy>();
    expectTypeOf(compat.min).toEqualTypeOf<typeof lodash.min>();
    expectTypeOf(compat.minBy).toEqualTypeOf<typeof lodash.minBy>();
    expectTypeOf(compat.multiply).toEqualTypeOf<typeof lodash.multiply>();
    expectTypeOf(compat.parseInt).toEqualTypeOf<typeof lodash.parseInt>();
    expectTypeOf(compat.random).toEqualTypeOf<typeof lodash.random>();
    expectTypeOf(compat.range).toEqualTypeOf<typeof lodash.range>();
    expectTypeOf(compat.rangeRight).toEqualTypeOf<typeof lodash.rangeRight>();
    expectTypeOf(compat.round).toEqualTypeOf<typeof lodash.round>();
    expectTypeOf(compat.subtract).toEqualTypeOf<typeof lodash.subtract>();
    expectTypeOf(compat.sum).toEqualTypeOf<typeof lodash.sum>();
    expectTypeOf(compat.sumBy).toEqualTypeOf<typeof lodash.sumBy>();

    // object
    expectTypeOf(compat.assign).toEqualTypeOf<typeof lodash.assign>();
    expectTypeOf(compat.assignIn).toEqualTypeOf<typeof lodash.assignIn>();
    expectTypeOf(compat.assignInWith).toEqualTypeOf<typeof lodash.assignInWith>();
    expectTypeOf(compat.assignWith).toEqualTypeOf<typeof lodash.assignWith>();
    expectTypeOf(compat.at).toEqualTypeOf<typeof lodash.at>();
    expectTypeOf(compat.clone).toEqualTypeOf<typeof lodash.clone>();
    expectTypeOf(compat.cloneDeep).toEqualTypeOf<typeof lodash.cloneDeep>();
    expectTypeOf(compat.cloneDeepWith).toEqualTypeOf<typeof lodash.cloneDeepWith>();
    expectTypeOf(compat.cloneWith).toEqualTypeOf<typeof lodash.cloneWith>();
    expectTypeOf(compat.create).toEqualTypeOf<typeof lodash.create>();
    expectTypeOf(compat.defaults).toEqualTypeOf<typeof lodash.defaults>();
    expectTypeOf(compat.defaultsDeep).toEqualTypeOf<typeof lodash.defaultsDeep>();
    expectTypeOf(compat.extend).toEqualTypeOf<typeof lodash.extend>();
    expectTypeOf(compat.extendWith).toEqualTypeOf<typeof lodash.extendWith>();
    expectTypeOf(compat.findKey).toEqualTypeOf<typeof lodash.findKey>();
    expectTypeOf(compat.findLastKey).toEqualTypeOf<typeof lodash.findLastKey>();
    expectTypeOf(compat.forIn).toEqualTypeOf<typeof lodash.forIn>();
    expectTypeOf(compat.forInRight).toEqualTypeOf<typeof lodash.forInRight>();
    expectTypeOf(compat.forOwn).toEqualTypeOf<typeof lodash.forOwn>();
    expectTypeOf(compat.forOwnRight).toEqualTypeOf<typeof lodash.forOwnRight>();
    expectTypeOf(compat.fromPairs).toEqualTypeOf<typeof lodash.fromPairs>();
    expectTypeOf(compat.functions).toEqualTypeOf<typeof lodash.functions>();
    expectTypeOf(compat.functionsIn).toEqualTypeOf<typeof lodash.functionsIn>();
    expectTypeOf(compat.get<unknown>).toEqualTypeOf<typeof lodash.get<unknown>>();
    expectTypeOf(compat.has<unknown>).toEqualTypeOf<typeof lodash.has<unknown>>();
    expectTypeOf(compat.hasIn).toEqualTypeOf<typeof lodash.hasIn>();
    expectTypeOf(compat.invert).toEqualTypeOf<typeof lodash.invert>();
    expectTypeOf(compat.invertBy).toEqualTypeOf<typeof lodash.invertBy>();
    expectTypeOf(compat.keys).toEqualTypeOf<typeof lodash.keys>();
    expectTypeOf(compat.keysIn).toEqualTypeOf<typeof lodash.keysIn>();
    expectTypeOf(compat.mapKeys).toEqualTypeOf<typeof lodash.mapKeys>();
    expectTypeOf(compat.mapValues).toEqualTypeOf<typeof lodash.mapValues>();
    expectTypeOf(compat.merge).toEqualTypeOf<typeof lodash.merge>();
    expectTypeOf(compat.mergeWith).toEqualTypeOf<typeof lodash.mergeWith>();
    expectTypeOf(compat.omit).toEqualTypeOf<typeof lodash.omit>();
    expectTypeOf(compat.omitBy).toEqualTypeOf<typeof lodash.omitBy>();
    expectTypeOf(compat.pick).toEqualTypeOf<typeof lodash.pick>();
    expectTypeOf(compat.pickBy).toEqualTypeOf<typeof lodash.pickBy>();
    expectTypeOf(compat.property).toEqualTypeOf<typeof lodash.property>();
    expectTypeOf(compat.propertyOf).toEqualTypeOf<typeof lodash.propertyOf>();
    expectTypeOf(compat.result).toEqualTypeOf<typeof lodash.result>();
    expectTypeOf(compat.set).toEqualTypeOf<typeof lodash.set>();
    expectTypeOf(compat.setWith).toEqualTypeOf<typeof lodash.setWith>();
    expectTypeOf(compat.toPairs).toEqualTypeOf<typeof lodash.toPairs>();
    expectTypeOf(compat.toPairsIn).toEqualTypeOf<typeof lodash.toPairsIn>();
    expectTypeOf(compat.transform).toEqualTypeOf<typeof lodash.transform>();
    expectTypeOf(compat.unset).toEqualTypeOf<typeof lodash.unset>();
    expectTypeOf(compat.update).toEqualTypeOf<typeof lodash.update>();
    expectTypeOf(compat.updateWith).toEqualTypeOf<typeof lodash.updateWith>();
    expectTypeOf(compat.values).toEqualTypeOf<typeof lodash.values>();
    expectTypeOf(compat.valuesIn).toEqualTypeOf<typeof lodash.valuesIn>();

    // predicate
    expectTypeOf(compat.conforms<unknown>).toEqualTypeOf<typeof lodash.conforms<unknown>>();
    expectTypeOf(compat.conformsTo<unknown>).toEqualTypeOf<typeof lodash.conformsTo<unknown>>();
    expectTypeOf(compat.isArguments).toEqualTypeOf<typeof lodash.isArguments>();
    expectTypeOf(compat.isArray).toEqualTypeOf<typeof lodash.isArray>();
    expectTypeOf(compat.isArrayBuffer).toEqualTypeOf<typeof lodash.isArrayBuffer>();
    expectTypeOf(compat.isArrayLike).toEqualTypeOf<typeof lodash.isArrayLike>();
    expectTypeOf(compat.isArrayLikeObject).toEqualTypeOf<typeof lodash.isArrayLikeObject>();
    expectTypeOf(compat.isBoolean).toEqualTypeOf<typeof lodash.isBoolean>();
    expectTypeOf(compat.isBuffer).toEqualTypeOf<typeof lodash.isBuffer>();
    expectTypeOf(compat.isDate).toEqualTypeOf<typeof lodash.isDate>();
    expectTypeOf(compat.isElement).toEqualTypeOf<typeof lodash.isElement>();
    expectTypeOf(compat.isEmpty).toEqualTypeOf<typeof lodash.isEmpty>();
    expectTypeOf(compat.isEqual).toEqualTypeOf<typeof lodash.isEqual>();
    expectTypeOf(compat.isEqualWith).toEqualTypeOf<typeof lodash.isEqualWith>();
    expectTypeOf(compat.isError).toEqualTypeOf<typeof lodash.isError>();
    expectTypeOf(compat.isFinite).toExtend<typeof lodash.isFinite>();
    expectTypeOf(compat.isFunction).toEqualTypeOf<typeof lodash.isFunction>();
    expectTypeOf(compat.isInteger).toEqualTypeOf<typeof lodash.isInteger>();
    expectTypeOf(compat.isLength).toEqualTypeOf<typeof lodash.isLength>();
    expectTypeOf(compat.isMap).toEqualTypeOf<typeof lodash.isMap>();
    expectTypeOf(compat.isMatch).toEqualTypeOf<typeof lodash.isMatch>();
    expectTypeOf(compat.isMatchWith).toEqualTypeOf<typeof lodash.isMatchWith>();
    expectTypeOf(compat.isNaN).toEqualTypeOf<typeof lodash.isNaN>();
    expectTypeOf(compat.isNative).toEqualTypeOf<typeof lodash.isNative>();
    expectTypeOf(compat.isNil).toEqualTypeOf<typeof lodash.isNil>();
    expectTypeOf(compat.isNull).toEqualTypeOf<typeof lodash.isNull>();
    expectTypeOf(compat.isNumber).toEqualTypeOf<typeof lodash.isNumber>();
    expectTypeOf(compat.isObject).toEqualTypeOf<typeof lodash.isObject>();
    expectTypeOf(compat.isObjectLike).toEqualTypeOf<typeof lodash.isObjectLike>();
    expectTypeOf(compat.isPlainObject).toEqualTypeOf<typeof lodash.isPlainObject>();
    expectTypeOf(compat.isRegExp).toEqualTypeOf<typeof lodash.isRegExp>();
    expectTypeOf(compat.isSafeInteger).toExtend<typeof lodash.isSafeInteger>();
    expectTypeOf(compat.isSet).toEqualTypeOf<typeof lodash.isSet>();
    expectTypeOf(compat.isString).toEqualTypeOf<typeof lodash.isString>();
    expectTypeOf(compat.isSymbol).toEqualTypeOf<typeof lodash.isSymbol>();
    expectTypeOf(compat.isTypedArray).toEqualTypeOf<typeof lodash.isTypedArray>();
    expectTypeOf(compat.isUndefined).toEqualTypeOf<typeof lodash.isUndefined>();
    expectTypeOf(compat.isWeakMap).toEqualTypeOf<typeof lodash.isWeakMap>();
    expectTypeOf(compat.isWeakSet).toEqualTypeOf<typeof lodash.isWeakSet>();
    expectTypeOf(compat.matches).toEqualTypeOf<typeof lodash.matches>();
    expectTypeOf(compat.matchesProperty).toEqualTypeOf<typeof lodash.matchesProperty>();

    // string
    expectTypeOf(compat.camelCase).toEqualTypeOf<typeof lodash.camelCase>();
    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
    // @ts-expect-error - es-toolkit's `capitalize` has a stricter return type than lodash
    expectTypeOf(compat.capitalize).toEqualTypeOf<typeof lodash.capitalize>();
    expectTypeOf(compat.deburr).toEqualTypeOf<typeof lodash.deburr>();
    expectTypeOf(compat.endsWith).toEqualTypeOf<typeof lodash.endsWith>();
    expectTypeOf(compat.escape).toEqualTypeOf<typeof lodash.escape>();
    expectTypeOf(compat.escapeRegExp).toEqualTypeOf<typeof lodash.escapeRegExp>();
    expectTypeOf(compat.kebabCase).toEqualTypeOf<typeof lodash.kebabCase>();
    expectTypeOf(compat.lowerCase).toEqualTypeOf<typeof lodash.lowerCase>();
    expectTypeOf(compat.lowerFirst).toEqualTypeOf<typeof lodash.lowerFirst>();
    expectTypeOf(compat.pad).toEqualTypeOf<typeof lodash.pad>();
    expectTypeOf(compat.padEnd).toEqualTypeOf<typeof lodash.padEnd>();
    expectTypeOf(compat.padStart).toEqualTypeOf<typeof lodash.padStart>();
    expectTypeOf(compat.repeat).toEqualTypeOf<typeof lodash.repeat>();
    expectTypeOf(compat.replace).toEqualTypeOf<typeof lodash.replace>();
    expectTypeOf(compat.snakeCase).toEqualTypeOf<typeof lodash.snakeCase>();
    expectTypeOf(compat.split).toEqualTypeOf<typeof lodash.split>();
    expectTypeOf(compat.startCase).toEqualTypeOf<typeof lodash.startCase>();
    expectTypeOf(compat.startsWith).toEqualTypeOf<typeof lodash.startsWith>();
    expectTypeOf(compat.template).toEqualTypeOf<typeof lodash.template>();
    // NOTE: expectTypeOf does not support checking custom TemplateSettings types
    // expectTypeOf(compat.templateSettings).toEqualTypeOf<typeof lodash.templateSettings>();
    expectTypeOf(compat.toLower).toEqualTypeOf<typeof lodash.toLower>();
    expectTypeOf(compat.toUpper).toEqualTypeOf<typeof lodash.toUpper>();
    expectTypeOf(compat.trim).toEqualTypeOf<typeof lodash.trim>();
    expectTypeOf(compat.trimEnd).toEqualTypeOf<typeof lodash.trimEnd>();
    expectTypeOf(compat.trimStart).toEqualTypeOf<typeof lodash.trimStart>();
    expectTypeOf(compat.truncate).toEqualTypeOf<typeof lodash.truncate>();
    expectTypeOf(compat.unescape).toEqualTypeOf<typeof lodash.unescape>();
    expectTypeOf(compat.upperCase).toEqualTypeOf<typeof lodash.upperCase>();
    expectTypeOf(compat.upperFirst).toEqualTypeOf<typeof lodash.upperFirst>();
    expectTypeOf(compat.words).toEqualTypeOf<typeof lodash.words>();

    // util
    expectTypeOf(compat.bindAll).toEqualTypeOf<typeof lodash.bindAll>();
    expectTypeOf(compat.cond).toEqualTypeOf<typeof lodash.cond>();
    expectTypeOf(compat.constant).toEqualTypeOf<typeof lodash.constant>();
    expectTypeOf(compat.defaultTo).toEqualTypeOf<typeof lodash.defaultTo>();
    expectTypeOf(compat.eq).toEqualTypeOf<typeof lodash.eq>();
    expectTypeOf(compat.gt).toEqualTypeOf<typeof lodash.gt>();
    expectTypeOf(compat.gte).toEqualTypeOf<typeof lodash.gte>();
    expectTypeOf(compat.invoke).toEqualTypeOf<typeof lodash.invoke>();
    expectTypeOf(compat.iteratee).toEqualTypeOf<typeof lodash.iteratee>();
    expectTypeOf(compat.lt).toEqualTypeOf<typeof lodash.lt>();
    expectTypeOf(compat.lte).toEqualTypeOf<typeof lodash.lte>();
    expectTypeOf(compat.method).toEqualTypeOf<typeof lodash.method>();
    expectTypeOf(compat.methodOf).toEqualTypeOf<typeof lodash.methodOf>();
    expectTypeOf(compat.now).toEqualTypeOf<typeof lodash.now>();
    expectTypeOf(compat.over).toEqualTypeOf<typeof lodash.over>();
    expectTypeOf(compat.overEvery).toEqualTypeOf<typeof lodash.overEvery>();
    expectTypeOf(compat.overSome).toEqualTypeOf<typeof lodash.overSome>();
    expectTypeOf(compat.stubArray).toEqualTypeOf<typeof lodash.stubArray>();
    expectTypeOf(compat.stubFalse).toEqualTypeOf<typeof lodash.stubFalse>();
    expectTypeOf(compat.stubObject).toEqualTypeOf<typeof lodash.stubObject>();
    expectTypeOf(compat.stubString).toEqualTypeOf<typeof lodash.stubString>();
    expectTypeOf(compat.stubTrue).toEqualTypeOf<typeof lodash.stubTrue>();
    expectTypeOf(compat.times).toEqualTypeOf<typeof lodash.times>();
    expectTypeOf(compat.toArray).toEqualTypeOf<typeof lodash.toArray>();
    expectTypeOf(compat.toFinite).toEqualTypeOf<typeof lodash.toFinite>();
    expectTypeOf(compat.toInteger).toEqualTypeOf<typeof lodash.toInteger>();
    expectTypeOf(compat.toLength).toEqualTypeOf<typeof lodash.toLength>();
    expectTypeOf(compat.toNumber).toEqualTypeOf<typeof lodash.toNumber>();
    expectTypeOf(compat.toPath).toEqualTypeOf<typeof lodash.toPath>();
    expectTypeOf(compat.toPlainObject).toEqualTypeOf<typeof lodash.toPlainObject>();
    expectTypeOf(compat.toSafeInteger).toEqualTypeOf<typeof lodash.toSafeInteger>();
    expectTypeOf(compat.toString).toEqualTypeOf<typeof lodash.toString>();
    expectTypeOf(compat.uniqueId).toEqualTypeOf<typeof lodash.uniqueId>();
  });
});
