types.txt

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.zip.transit.json  ===
insert-child {2 {:ret :vector}}
left {1 {:ret #{:vector :nil}}}
append-child {2 {:ret :vector}}
down {1 {:ret #{:vector :nil}}}
replace {2 {:ret :vector}}
zipper {4 {:ret :vector}}
end? {1 {:ret :boolean}}
edit {:varargs {:ret :vector, :min-arity 2}}
vector-zip {1 {:ret :vector}}
up {1 {:ret #{:vector :nil}}}
seq-zip {1 {:ret :vector}}
right {1 {:ret #{:vector :nil}}}
lefts {1 {:ret :seq}}
xml-zip {1 {:ret :vector}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.core.server.transit.json  ===
thread {:varargs {:min-arity 2, :args (:nilable/string nil nil nil)}}
ex->data {2 {:ret :associative}}
remote-prepl {:varargs {:min-arity 4, :args (:nilable/string nil nil nil nil nil)}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.math.transit.json  ===
next-after {2 {:ret :double, :args (:double :double)}}
to-radians {1 {:ret :double, :args (:double)}}
log {1 {:ret :double, :args (:double)}}
acos {1 {:ret :double, :args (:double)}}
to-degrees {1 {:ret :double, :args (:double)}}
floor {1 {:ret :double, :args (:double)}}
atan2 {2 {:ret :double, :args (:double :double)}}
hypot {2 {:ret :double, :args (:double :double)}}
tanh {1 {:ret :double, :args (:double)}}
floor-mod {2 {:ret :int, :args (:int :int)}}
ceil {1 {:ret :double, :args (:double)}}
atan {1 {:ret :double, :args (:double)}}
multiply-exact {2 {:ret :int, :args (:int :int)}}
expm1 {1 {:ret :double, :args (:double)}}
get-exponent {1 {:args (:double)}}
add-exact {2 {:ret :int, :args (:int :int)}}
cos {1 {:ret :double, :args (:double)}}
log10 {1 {:ret :double, :args (:double)}}
tan {1 {:ret :double, :args (:double)}}
cbrt {1 {:ret :double, :args (:double)}}
sqrt {1 {:ret :double, :args (:double)}}
decrement-exact {1 {:ret :int, :args (:int)}}
next-down {1 {:ret :double, :args (:double)}}
pow {2 {:ret :double, :args (:double :double)}}
next-up {1 {:ret :double, :args (:double)}}
exp {1 {:ret :double, :args (:double)}}
subtract-exact {2 {:ret :int, :args (:int :int)}}
cosh {1 {:ret :double, :args (:double)}}
scalb {2 {:ret :double, :args (:double nil)}}
log1p {1 {:ret :double, :args (:double)}}
asin {1 {:ret :double, :args (:double)}}
copy-sign {2 {:ret :double, :args (:double :double)}}
round {1 {:ret :int, :args (:double)}}
negate-exact {1 {:ret :int, :args (:int)}}
IEEE-remainder {2 {:ret :double, :args (:double :double)}}
sinh {1 {:ret :double, :args (:double)}}
rint {1 {:ret :double, :args (:double)}}
ulp {1 {:ret :double, :args (:double)}}
sin {1 {:ret :double, :args (:double)}}
increment-exact {1 {:ret :int, :args (:int)}}
random {0 {:ret :double}}
floor-div {2 {:ret :int, :args (:int :int)}}
signum {1 {:ret :double, :args (:double)}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.spec.gen.alpha.transit.json  ===
qualified? {1 {:ret :boolean}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.test.transit.json  ===
file-position {1 {:ret :vector}}
file-and-line {2 {:ret #{{:type :map, :val {:file {:row 341, :col 16, :end-row 341, :end-col 32}, :line {:row 341, :col 39, :end-row 341, :end-col 57}}, :row 341, :col 9, :end-row 341, :end-col 58} {:type :map, :val {:file {:row 342, :col 14, :end-row 342, :end-col 17, :tag :nil}, :line {:row 342, :col 24, :end-row 342, :end-col 27, :tag :nil}}, :row 342, :col 7, :end-row 342, :end-col 28}}}}
stacktrace-file-and-line {1 {:ret #{{:type :map, :val {:file {:row 348, :col 14, :end-row 348, :end-col 30}, :line {:row 348, :col 37, :end-row 348, :end-col 55}}, :row 348, :col 7, :end-row 348, :end-col 56} {:type :map, :val {:file {:row 349, :col 12, :end-row 349, :end-col 15, :tag :nil}, :line {:row 349, :col 22, :end-row 349, :end-col 25, :tag :nil}}, :row 349, :col 5, :end-row 349, :end-col 26}}}}
compose-fixtures {2 {:ret :fn}}
function? {1 {:ret #{:nil :boolean}}}
successful? {1 {:ret #{:nil :boolean}}}
testing-vars-str {1 {:ret :string}}
run-tests {0 {:ret :associative}, :varargs {:ret :associative, :min-arity 0}}

===  resources/clj_kondo/impl/cache/built_in/clj/java.math.BigInteger.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.Math.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.CharSequence.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.datafy.transit.json  ===
sortmap {1 {:ret :sorted-map}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.java.shell.transit.json  ===
parse-args {1 {:ret :vector}}

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.Double.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.Thread.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.core.specs.alpha.transit.json  ===
even-number-of-forms? {1 {:ret :boolean}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.core.protocols.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.test.junit.transit.json  ===
suite-attrs {2 {:ret #{{:type :map, :val {:name {:row 99, :col 22, :end-row 99, :end-col 31}}, :row 101, :col 7, :end-row 101, :end-col 37} {:type :map, :val {:name {:row 99, :col 22, :end-row 99, :end-col 31}}, :row 102, :col 7, :end-row 102, :end-col 12}}}}
package-class {1 {:ret #{:vector}}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.pprint.transit.json  ===
toks {1 {:ret :seq}}
brackets {1 {:ret #{:vector}}}
get-section {1 {:ret :vector}}
buffer-length {1 {:ret #{:number :nat-int}}}
integral? {1 {:ret #{:boolean}}}
write-initial-lines {2 {:args (nil :nilable/string)}}
insert-scaled-decimal {2 {:ret #{:string}}}
round-str {4 {:ret #{:vector}}}
float-parts-base {1 {:ret #{:vector}}}
set-max-column {2 {:ret :nil}}
c-write-char {2 {:args (nil :nilable/int)}}
realize-parameter-list {2 {:ret :vector}}
get-format-arg {1 {:ret :vector}}
split-at-newline {1 {:ret :vector}}
group-by* {2 {:ret :seq}}
insert-decimal {2 {:ret #{:string}}}
realize-parameter {2 {:ret :vector}}
get-sub-section {1 {:ret :seq}}
execute-format {2 {:ret :nil}}
inc-s {1 {:args (:nilable/string)}}
unzip-map {1 {:ret :vector}}
next-arg-or-nil {1 {:ret #{:vector}}}
format-simple-ordinal {1 {:ret :string}}
start-block {4 {:args (nil :nilable/string :nilable/string :nilable/string)}}
process-directive-table-element {1 {:ret :vector}}
set-pprint-dispatch {1 {:ret :nil}}
remainders {2 {:ret :seq}}
process-bracket {2 {:ret :vector}}
translate-param {1 {:ret :vector}}
pprint-reader-macro {1 {:ret #{:nil :boolean}}}
compile-directive {2 {:ret :vector}}
two-forms {1 {:ret {:type :map, :val {}}}}
add-core-ns {1 {:ret {:type :map, :val {}, :row 439, :col 5, :end-row 444, :end-col 22}}}
format-simple-cardinal {1 {:ret :string}}
float-parts {1 {:ret #{:vector}}}
get-fixed {3 {:ret #{:string}}}
abort? {1 {:ret #{:boolean}}}
map-params {4 {:ret :nilable/map}}
p-write-char {2 {:args (nil :nilable/int)}}
tokens-fit? {2 {:ret #{:boolean}}}
tuple-map {2 {:ret {:type :map, :val {}}}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.spec.alpha.transit.json  ===
alt-impl {3 {:ret :associative}}
pvalid? {2 {:ret :boolean}, 3 {:ret :boolean}}
explain-data* {5 {:ret #{{:type :map, :val #:clojure.spec.alpha{:problems {:row 221, :col 19, :end-row 221, :end-col 24, :tag {:call {:filename clojure/spec/alpha.clj, :type :call, :lang :clj, :base-lang :clj, :resolved-ns clojure.spec.alpha, :ns clojure.spec.alpha, :name explain*, :arity 5}}}, :spec {:row 222, :col 15, :end-row 222, :end-col 19}, :value {:row 223, :col 16, :end-row 223, :end-col 17}}, :row 221, :col 7, :end-row 223, :end-col 18} :nil}}}
fn-sym {1 {:ret #{:symbol :nil}}}
inst-in-range? {3 {:ret #{:nil :boolean}}}
accept? {1 {:ret :boolean}}
accept {1 {:ret {:type :map, :val {:clojure.spec.alpha/op {:row 1382, :col 25, :end-row 1382, :end-col 33, :tag :keyword}, :ret {:row 1382, :col 39, :end-row 1382, :end-col 40}}}}}
recur-limit? {4 {:ret #{:nil :boolean}}}
valid? {2 {:ret :boolean}, 3 {:ret :boolean}}
int-in-range? {3 {:ret #{:nil :boolean}}}
exercise {1 {:ret :seq}, 2 {:ret :seq}, 3 {:ret :seq}}
explain-data {2 {:ret #{{:type :map, :val #:clojure.spec.alpha{:problems {:row 221, :col 19, :end-row 221, :end-col 24, :tag {:call {:filename clojure/spec/alpha.clj, :type :call, :lang :clj, :base-lang :clj, :resolved-ns clojure.spec.alpha, :ns clojure.spec.alpha, :name explain*, :arity 5}}}, :spec {:row 222, :col 15, :end-row 222, :end-col 19}, :value {:row 223, :col 16, :end-row 223, :end-col 17}}, :row 221, :col 7, :end-row 223, :end-col 18} :nil}}}
inck {2 {:ret :associative}}
invalid? {1 {:ret :boolean}}
amp-impl {4 {:ret {:type :map, :val {:clojure.spec.alpha/op {:row 1423, :col 9, :end-row 1423, :end-col 14, :tag :keyword}, :p1 {:row 1423, :col 19, :end-row 1423, :end-col 21}, :amp {:row 1423, :col 27, :end-row 1423, :end-col 34}, :ps {:row 1423, :col 39, :end-row 1423, :end-col 44}, :forms {:row 1423, :col 52, :end-row 1423, :end-col 62}}}}}
explain-str {2 {:ret :nilable/string}}
rep-impl {2 {:ret #{{:type :map, :val {:clojure.spec.alpha/op {:row 1406, :col 19, :end-row 1406, :end-col 24, :tag :keyword}, :p2 {:row 1406, :col 30, :end-row 1406, :end-col 32}, :splice {:row 1406, :col 42, :end-row 1406, :end-col 48}, :forms {:row 1406, :col 57, :end-row 1406, :end-col 61}, :id {:row 1406, :col 66, :end-row 1406, :end-col 93}}, :row 1408, :col 9, :end-row 1408, :end-col 51} :nil {:type :map, :val {:clojure.spec.alpha/op {:row 1406, :col 19, :end-row 1406, :end-col 24, :tag :keyword}, :p2 {:row 1406, :col 30, :end-row 1406, :end-col 32}, :splice {:row 1406, :col 42, :end-row 1406, :end-col 48}, :forms {:row 1406, :col 57, :end-row 1406, :end-col 61}, :id {:row 1406, :col 66, :end-row 1406, :end-col 93}}, :row 1409, :col 9, :end-row 1409, :end-col 35}}}}
filter-alt {4 {:ret #{:vector}}}
call-valid? {3 {:ret #{:nil :boolean}}}
rep* {5 {:ret #{{:type :map, :val {:clojure.spec.alpha/op {:row 1406, :col 19, :end-row 1406, :end-col 24, :tag :keyword}, :p2 {:row 1406, :col 30, :end-row 1406, :end-col 32}, :splice {:row 1406, :col 42, :end-row 1406, :end-col 48}, :forms {:row 1406, :col 57, :end-row 1406, :end-col 61}, :id {:row 1406, :col 66, :end-row 1406, :end-col 93}}, :row 1408, :col 9, :end-row 1408, :end-col 51} :nil {:type :map, :val {:clojure.spec.alpha/op {:row 1406, :col 19, :end-row 1406, :end-col 24, :tag :keyword}, :p2 {:row 1406, :col 30, :end-row 1406, :end-col 32}, :splice {:row 1406, :col 42, :end-row 1406, :end-col 48}, :forms {:row 1406, :col 57, :end-row 1406, :end-col 61}, :id {:row 1406, :col 66, :end-row 1406, :end-col 93}}, :row 1409, :col 9, :end-row 1409, :end-col 35}}}}
maybe-impl {2 {:ret :associative}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.stacktrace.transit.json  ===
print-throwable {1 {:ret #{:nil}}}

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.System.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.string.transit.json  ===
ends-with? {2 {:args (:nilable/char-sequence :nilable/string)}}
replace-first-char {3 {:args (:nilable/char-sequence :nilable/char nil)}}
capitalize {1 {:args (:nilable/char-sequence)}}
reverse {1 {:args (:nilable/char-sequence)}}
replace-first {3 {:args (:nilable/char-sequence nil nil)}}
replace-first-str {3 {:ret #{:nilable/string :string}, :args (:nilable/char-sequence :nilable/string :nilable/string)}}
starts-with? {2 {:args (:nilable/char-sequence :nilable/string)}}
escape {2 {:args (:nilable/char-sequence nil)}}
last-index-of {2 {:args (:nilable/char-sequence nil)}, 3 {:args (:nilable/char-sequence nil :int)}}
re-quote-replacement {1 {:args (:nilable/char-sequence)}}
includes? {2 {:args (:nilable/char-sequence :nilable/char-sequence)}}
replace {3 {:args (:nilable/char-sequence nil nil)}}
split-lines {1 {:args (:nilable/char-sequence)}}
lower-case {1 {:args (:nilable/char-sequence)}}
trim-newline {1 {:args (:nilable/char-sequence)}}
replace-by {3 {:args (:nilable/char-sequence nil nil)}}
replace-first-by {3 {:ret #{:nilable/char-sequence :string}, :args (:nilable/char-sequence nil nil)}}
upper-case {1 {:args (:nilable/char-sequence)}}
split {2 {:args (:nilable/char-sequence nil)}, 3 {:args (:nilable/char-sequence nil nil)}}
trimr {1 {:args (:nilable/char-sequence)}}
index-of {2 {:args (:nilable/char-sequence nil)}, 3 {:args (:nilable/char-sequence nil :int)}}
trim {1 {:args (:nilable/char-sequence)}}
triml {1 {:args (:nilable/char-sequence)}}
blank? {1 {:args (:nilable/char-sequence)}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.set.transit.json  ===
union {0 {:ret :set}}
superset? {2 {:ret #{:nil :boolean}}}
subset? {2 {:ret #{:nil :boolean}}}
rename {2 {:ret :set}}
project {2 {:ret :set}}

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.Boolean.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.java.io.transit.json  ===
append? {1 {:ret :boolean}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.java.browse-ui.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.repl.transit.json  ===
namespace-doc {1 {:ret :associative}}
special-doc {1 {:ret :associative}}
stack-element-str {1 {:ret :string}}
dir-fn {1 {:ret #{:list :seq}}}
thread-stopper {0 {:ret :fn}, 1 {:ret :fn}}
apropos {1 {:ret #{:list :seq}}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.inspector.transit.json  ===
atom? {1 {:ret :boolean}}
collection-tag {1 {:ret #{:keyword}}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.instant.transit.json  ===
validated {1 {:ret :fn}}
zero-fill-right {2 {:args (:nilable/string nil)}}
leap-year? {1 {:ret #{:nil :boolean}}}
divisible? {2 {:ret :boolean}}
read-instant-timestamp {1 {:args (:nilable/char-sequence)}}
indivisible? {2 {:ret :boolean}}
parse-int {1 {:args (:nilable/string)}}
read-instant-calendar {1 {:args (:nilable/char-sequence)}}
read-instant-date {1 {:args (:nilable/char-sequence)}}
parse-timestamp {2 {:args (nil :nilable/char-sequence)}}

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.Long.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.tools.reader.transit.json  ===
unquote-splicing? {1 {:ret #{:nil :boolean}}}
starting-line-col-info {1 {:ret #{:vector :nil}}}
wrapping-reader {1 {:ret :fn}}
read+string {0 {:ret :vector}, 1 {:ret :vector}, 3 {:ret :vector}, 2 {:ret :vector}}
read-unicode-char {4 {:args (:nilable/string :int :int :int)}}
unquote? {1 {:ret #{:nil :boolean}}}
syntax-quote-coll {2 {:ret #{:list}}}
check-eof-error {3 {:args (nil nil :int)}}
check-invalid-read-cond {3 {:args (nil nil :int)}}
map-func {1 {:ret #{:symbol}}}
ending-line-col-info {1 {:ret #{:vector :nil}}}
garg {1 {:ret :symbol, :args (:int)}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.parallel.transit.json  ===
pdistinct {1 {:ret :vector}}
pvec {1 {:ret :vector}}
pa-to-vec {1 {:ret :vector}}
psummary {1 {:ret {:type :map, :val {:min {:row 156, :col 9, :end-row 156, :end-col 17}, :max {:row 156, :col 23, :end-row 156, :end-col 31}, :size {:row 156, :col 38, :end-row 156, :end-col 47}, :min-index {:row 156, :col 59, :end-row 156, :end-col 74}, :max-index {:row 156, :col 86, :end-row 156, :end-col 101}}}}, 2 {:ret {:type :map, :val {:min {:row 156, :col 9, :end-row 156, :end-col 17}, :max {:row 156, :col 23, :end-row 156, :end-col 31}, :size {:row 156, :col 38, :end-row 156, :end-col 47}, :min-index {:row 156, :col 59, :end-row 156, :end-col 74}, :max-index {:row 156, :col 86, :end-row 156, :end-col 101}}}}}
pfilter-nils {1 {:ret :vector}}
summary-map {1 {:ret {:type :map, :val {:min {:row 156, :col 9, :end-row 156, :end-col 17}, :max {:row 156, :col 23, :end-row 156, :end-col 31}, :size {:row 156, :col 38, :end-row 156, :end-col 47}, :min-index {:row 156, :col 59, :end-row 156, :end-col 74}, :max-index {:row 156, :col 86, :end-row 156, :end-col 101}}}}}
psort {1 {:ret :vector}, 2 {:ret :vector}}
pfilter-dupes {1 {:ret :vector}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.main.transit.json  ===
stack-element-str {1 {:ret :string}}
core-class? {1 {:args (:nilable/string)}}
java-loc->source {2 {:ret #{:symbol}}}
load-script {1 {:args (:nilable/string)}}
file-name {1 {:args (:nilable/string)}}
file-path {1 {:args (:nilable/string)}}
ex-triage {1 {:ret :associative}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.walk.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.template.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.data.json.transit.json  ===
codepoint-clause {1 {:ret #{:vector}}}
slow-read-string {2 {:args (nil :nilable/string)}}
write-double {3 {:args (:nilable/double nil nil)}}
write-str {:varargs {:ret :nilable/string, :min-arity 1}}
read-integer {1 {:args (:nilable/string)}}
write-string {3 {:args (:nilable/char-sequence nil nil)}}
write-float {3 {:args (:nilable/double nil nil)}}
read-decimal {2 {:args (:nilable/string nil)}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.xml.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.core.reducers.transit.json  ===
cat {1 {:ret :fn}}
monoid {2 {:ret :fn}}

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.String.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/java.math.BigDecimal.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.Character.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.reflect.transit.json  ===
access-flag {1 {:ret {:type :map, :val {:name {:row 57, :col 10, :end-row 57, :end-col 14}, :flag {:row 57, :col 21, :end-row 57, :end-col 25}, :contexts {:row 57, :col 36, :end-row 57, :end-col 64}}}}}
declared-constructors {1 {:ret :set}}
parse-method-descriptor {1 {:ret {:type :map, :val {:parameter-types {:row 193, :col 21, :end-row 193, :end-col 67}, :return-type {:row 194, :col 17, :end-row 194, :end-col 50}}}, :args (:nilable/string)}}
field-descriptor->class-symbol {1 {:args (:nilable/string)}}
declared-fields {1 {:ret :set}}
declared-methods {1 {:ret :set}}

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.Integer.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.edn.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.java.browse.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.uuid.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.core.transit.json  ===
+' {0 {:ret :nat-int}}
sort-by {2 {:ret #{:list :seq}}, 3 {:ret #{:list :seq}}}
is-runtime-annotation? {1 {:ret :boolean}}
tree-seq {3 {:ret :seq}}
keep-indexed {1 {:ret :fn}}
subs {2 {:ret :nilable/string, :args (:nilable/string nil)}, 3 {:ret :nilable/string, :args (:nilable/string nil nil)}}
reader-conditional {2 {:args (nil :nilable/boolean)}}
qualified-keyword? {1 {:ret :boolean}}
satisfies? {2 {:ret :boolean}}
take-nth {1 {:ret :fn}, 2 {:ret :seq}}
newline {0 {:ret :nil}}
dedupe {0 {:ret :fn}}
pr-on {2 {:ret :nil}}
mk-bound-fn {3 {:ret :fn}}
pr {0 {:ret :nil}, 1 {:ret :nil}}
= {1 {:ret :boolean}}
take {1 {:ret :fn}, 2 {:ret :seq}}
thread-bound? {:varargs {:ret :boolean, :min-arity 0}}
any? {1 {:ret :boolean}}
rand-int {1 {:ret :int}}
map {1 {:ret :fn}, 2 {:ret :seq}, 3 {:ret :seq}, 4 {:ret :seq}, :varargs {:ret :seq, :min-arity 4}}
juxt {1 {:ret :fn}, 2 {:ret :fn}, 3 {:ret :fn}, :varargs {:ret :fn, :min-arity 3}}
< {1 {:ret :boolean}}
NaN? {1 {:args (:double)}}
make-hierarchy {0 {:ret {:type :map, :val {:parents {:row 5557, :col 16, :end-row 5557, :end-col 18, :tag {:type :map, :val {}}}, :descendants {:row 5557, :col 32, :end-row 5557, :end-col 34, :tag {:type :map, :val {}}}, :ancestors {:row 5557, :col 46, :end-row 5557, :end-col 48, :tag {:type :map, :val {}}}}}}}
keep {1 {:ret :fn}, 2 {:ret :seq}}
unchecked-long {1 {:args (:nilable/number)}}
some? {1 {:ret :boolean}}
get-super-and-interfaces {1 {:ret #{:vector}}}
remove-tap {1 {:ret :nil}}
inst? {1 {:ret :boolean}}
range {0 {:ret :seq}}
sort {1 {:ret #{:list :seq}}, 2 {:ret #{:list :seq}}}
generate-class {1 {:ret :vector}}
map-indexed {1 {:ret :fn}}
comp {2 {:ret :fn}}
simple-symbol? {1 {:ret #{:nil :boolean}}}
fnil {2 {:ret :fn}, 3 {:ret :fn}, 4 {:ret :fn}}
unchecked-float {1 {:args (:nilable/number)}}
pmap {2 {:ret :seq}, :varargs {:ret :seq, :min-arity 2}}
cat {1 {:ret :fn}}
StackTraceElement->vec {1 {:ret :vector}}
flush {0 {:ret :nil}}
take-while {1 {:ret :fn}, 2 {:ret :seq}}
<= {1 {:ret :boolean}}
repeatedly {1 {:ret :seq}, 2 {:ret :seq}}
remove {1 {:ret :transducer}, 2 {:ret :seq}}
* {0 {:ret :pos-int}}
nary-inline {1 {:ret :fn}, 2 {:ret :fn}}
format {:varargs {:ret :nilable/string, :min-arity 1}}
conj {0 {:ret :vector}}
bound? {:varargs {:ret :boolean, :min-arity 0}}
parse-opts+specs {1 {:ret :vector}}
interleave {1 {:ret :seq}, 2 {:ret :seq}, :varargs {:ret :seq, :min-arity 2}}
protocol? {1 {:ret :boolean}}
into {0 {:ret :vector}}
long {1 {:args (:nilable/number)}}
double {1 {:args (:nilable/number)}}
nfirst {1 {:ret :seq}}
method-sig {1 {:ret :vector}}
hash-ordered-coll {1 {:ret :int}}
deref-as-map {1 {:ret {:type :map, :val {:status {:row 445, :col 6, :end-row 455, :end-col 14, :tag #{{:tag :keyword, :row 452, :col 7, :end-row 452, :end-col 15} {:tag :keyword, :row 455, :col 7, :end-row 455, :end-col 13} {:tag :keyword, :row 449, :col 7, :end-row 449, :end-col 14}}}, :val {:row 457, :col 11, :end-row 457, :end-col 14}}, :row 444, :col 5, :end-row 457, :end-col 15}}}
seque {1 {:ret :seq}, 2 {:ret :seq}}
empty? {1 {:ret :boolean}}
short {1 {:args (:nilable/number)}}
pref {0 {:ret :nil}}
add-tap {1 {:ret :nil}}
unchecked-double {1 {:args (:nilable/number)}}
not= {1 {:ret :boolean}, 2 {:ret :boolean}, :varargs {:ret :boolean, :min-arity 2}}
pcalls {:varargs {:ret :seq, :min-arity 0}}
fits-table? {1 {:ret :boolean}}
rand {1 {:ret :number}}
> {1 {:ret :boolean}}
replace {1 {:ret :transducer}}
unchecked-int {1 {:args (:nilable/number)}}
bound-fn* {1 {:ret :fn}}
prn {:varargs {:ret #{:nil}, :min-arity 0}}
defn {:varargs {:ret :list, :min-arity 3}}
extends? {2 {:ret :boolean}}
agent-errors {1 {:ret #{:list :nil}}}
float {1 {:args (:nilable/number)}}
concat {0 {:ret :seq}, 1 {:ret :seq}, 2 {:ret :seq}, :varargs {:ret :seq, :min-arity 2}}
valid-java-method-name {1 {:ret :boolean, :args (:nilable/string)}}
mod {2 {:ret #{:number}}}
reductions {2 {:ret :seq}}
hash-set {0 {:ret :set}}
emit-hinted-impl {2 {:ret :vector}}
strip-ns {1 {:ret #{:symbol :keyword}}}
parse-double {1 {:ret :nilable/double, :args (:nilable/string)}}
assoc-in {3 {:ret #{:associative}}}
memoize {1 {:ret :fn}}
simple-keyword? {1 {:ret #{:nil :boolean}}}
nnext {1 {:ret :seq}}
neg-int? {1 {:ret #{:nil :boolean}}}
drop {1 {:ret :fn}, 2 {:ret :seq}}
split-at {2 {:ret :vector}}
random-sample {1 {:ret :transducer}, 2 {:ret :seq}}
update {3 {:ret :associative}, 4 {:ret :associative}, 5 {:ret :associative}, 6 {:ret :associative}, :varargs {:ret :associative, :min-arity 6}}
group-by-sig {1 {:ret :seq}}
list* {1 {:ret :seq}}
update-in {:varargs {:ret #{:associative}, :min-arity 3}}
*' {0 {:ret :pos-int}}
mix-collection-hash {2 {:ret :int, :args (:int :int)}}
re-find {2 {:ret #{:string :vector}}}
run! {2 {:ret :nil}}
print-sequential {6 {:args (:nilable/string nil :nilable/string :nilable/string nil nil)}}
not {1 {:ret #{:boolean}}}
file-seq {1 {:ret :seq}}
ident? {1 {:ret #{:boolean}}}
qualified-ident? {1 {:ret :boolean}}
/ {1 {:ret :number}}
binding-conveyor-fn {1 {:ret :fn}}
vector {0 {:ret :vector}, 1 {:ret :vector}, 2 {:ret :vector}, 3 {:ret :vector}, 4 {:ret :vector}, 5 {:ret :vector}, 6 {:ret :vector}}
>= {1 {:ret :boolean}}
drop-last {1 {:ret :seq}, 2 {:ret :seq}}
root-directory {1 {:ret :string}}
distinct {0 {:ret :fn}, 1 {:ret :seq}}
partition {2 {:ret :seq}, 3 {:ret :seq}, 4 {:ret :seq}}
data-reader-urls {0 {:ret :seq}}
mapv {3 {:ret :vector}, 4 {:ret :vector}, :varargs {:ret :vector, :min-arity 4}}
infinite? {1 {:args (:double)}}
partition-all {1 {:ret :fn, :args (:int)}, 2 {:ret :seq}, 3 {:ret :seq}}
partition-by {1 {:ret :fn}, 2 {:ret :seq}}
derive {2 {:ret :nil}}
special-symbol? {1 {:ret :boolean}}
prep-hashes {4 {:ret #{:vector}}}
subseq {5 {:ret #{:nil :seq}}}
parsing-err {1 {:ret :nilable/string}}
flatten {1 {:ret :seq}}
halt-when {1 {:ret :fn}, 2 {:ret :fn}}
nat-int? {1 {:ret #{:nil :boolean}}}
subvec {2 {:ret :vector}}
partial {2 {:ret :fn}, 3 {:ret :fn}, 4 {:ret :fn}, :varargs {:ret :fn, :min-arity 4}}
replicate {2 {:ret :seq}}
unchecked-byte {1 {:args (:nilable/number)}}
defmacro {:varargs {:ret :list, :min-arity 3}}
every-pred {1 {:ret :fn}, 2 {:ret :fn}, 3 {:ret :fn}, :varargs {:ret :fn, :min-arity 3}}
distinct? {1 {:ret :boolean}, 2 {:ret :boolean}}
pos-int? {1 {:ret #{:nil :boolean}}}
prep-ints {2 {:ret #{:vector}}}
extenders {1 {:ret :seq}}
unchecked-short {1 {:args (:nilable/number)}}
odd? {1 {:ret :boolean}}
rsubseq {5 {:ret #{:nil :seq}}}
filter {1 {:ret :fn}, 2 {:ret :seq}}
+ {0 {:ret :nat-int}}
split-with {2 {:ret :vector}}
ctor-sigs {1 {:ret :seq}}
str {0 {:ret :nilable/string}, 1 {:ret :nilable/string}, :varargs {:ret :nilable/string, :min-arity 1}}
hash-map {0 {:ret {:type :map, :val {}}}}
underive {2 {:ret :nil}}
Throwable->map {1 {:ret :nilable/map}}
some-fn {1 {:ret :fn}, 2 {:ret :fn}, 3 {:ret :fn}, :varargs {:ret :fn, :min-arity 3}}
simple-ident? {1 {:ret #{:nil :boolean}}}
parse-uuid {1 {:args (:nilable/string)}}
generate-interface {1 {:ret :vector}}
xml-seq {1 {:ret :seq}}
byte {1 {:args (:nilable/number)}}
== {1 {:ret :boolean}}
root-resource {1 {:ret :string}}
generate-proxy {2 {:ret :vector}}
interpose {1 {:ret :fn}, 2 {:ret :seq}}
emit-impl {1 {:ret :vector}}
parse-boolean {1 {:args (:nilable/string)}}
rational? {1 {:ret #{:boolean}}}
clojure-version {0 {:ret :string}}
merge-hash-collisions {4 {:ret :vector}}
comparator {1 {:ret :fn}}
drop-while {1 {:ret :fn}, 2 {:ret :seq}}
complement {1 {:ret :fn}}
constantly {1 {:ret :fn}}
completing {1 {:ret :fn}, 2 {:ret :fn}}
hash-unordered-coll {1 {:ret :int}}
preserving-reduced {1 {:ret :fn}}
qualified-symbol? {1 {:ret :boolean}}
parse-long {1 {:ret :nilable/int, :args (:nilable/string)}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.data.transit.json  ===
atom-diff {2 {:ret #{:vector}}}
diff-associative-key {3 {:ret :vector}}
diff-sequential {2 {:ret :vector}}

===  resources/clj_kondo/impl/cache/built_in/clj/java.lang.Byte.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.test.tap.transit.json  ===

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.java.javadoc.transit.json  ===
fill-in-module-name {2 {:ret #{:nilable/string :string}, :args (:nilable/string :nilable/string)}}
javadoc-url {1 {:args (:nilable/string)}}

===  resources/clj_kondo/impl/cache/built_in/clj/clojure.spec.test.alpha.transit.json  ===
build-fixed-args-body {2 {:ret :list}}
explain-check {4 {:ret :throwable}}
interpret-stack-trace-element {1 {:ret :nilable/map}}
build-varargs-body {2 {:ret :list}}
spec-checking-fn {3 {:ret :fn}}
fn-spec-name? {1 {:ret #{:nil :boolean}}}
check-call {3 {:ret #{:throwable :boolean}}}
no-fspec {2 {:ret :throwable}}
make-check-result {3 {:ret :nilable/map}}
enumerate-namespace {1 {:ret :set}}
sym->check-map {1 {:ret {:type :map, :val {:s {:row 460, :col 9, :end-row 460, :end-col 10}, :v {:row 461, :col 9, :end-row 461, :end-col 10, :tag {:call {:filename clojure/spec/test/alpha.clj, :type :call, :lang :clj, :base-lang :clj, :resolved-ns clojure.core, :ns clojure.spec.test.alpha, :name resolve, :arity 1}}}, :spec {:row 462, :col 12, :end-row 462, :end-col 35, :tag #{{:call {:filename clojure/spec/test/alpha.clj, :type :call, :lang :clj, :base-lang :clj, :resolved-ns clojure.spec.alpha, :ns clojure.spec.test.alpha, :name get-spec, :arity 1}, :row 462, :col 20, :end-row 462, :end-col 34} :nil}}}, :row 460, :col 5, :end-row 462, :end-col 36}}}
thunk-frame? {1 {:ret :boolean}}
build-kwargs-body {2 {:ret :list}}