@pithos/core 2.0.0

package/dist/autocompletion.d.ts

@@ -0,0 +1,1627 @@
+/**
+ * 🤖 Autocompletion file generated automatically
+ * ⚠️  DO NOT MODIFY MANUALLY
+ * 
+ * This file provides structured autocompletion for your IDE.
+ * Navigate through the structure: math.geometry.distance
+ * 
+ * To preserve tree-shaking in production, use direct imports:
+ * ❌ import { distance } from 'pithos/autocompletion';
+ * ❌ const distance = math.geometry.distance; // from autocompletion
+ * ✅ import { distance } from 'pithos/math/geometry';
+ * 
+ * Generated on: 2026-02-22T16:49:34.264Z
+ * */
+
+/** 
+ * @deprecated ⚠️ This nested structure is for autocompletion only.
+ * Use direct imports in production to preserve tree-shaking.
+ */
+declare const _autocompletion: {
+  arkhe: {
+        chunk: {
+          chunk: typeof import('./arkhe/array/chunk')['chunk'];
+        };
+        count_by: {
+          countBy: typeof import('./arkhe/array/count-by')['countBy'];
+        };
+        difference: {
+          difference: typeof import('./arkhe/array/difference')['difference'];
+        };
+        difference_by: {
+          differenceBy: typeof import('./arkhe/array/difference-by')['differenceBy'];
+        };
+        difference_with: {
+          differenceWith: typeof import('./arkhe/array/difference-with')['differenceWith'];
+        };
+        drop: {
+          drop: typeof import('./arkhe/array/drop')['drop'];
+        };
+        drop_right: {
+          dropRight: typeof import('./arkhe/array/drop-right')['dropRight'];
+        };
+        drop_right_while: {
+          dropRightWhile: typeof import('./arkhe/array/drop-right-while')['dropRightWhile'];
+        };
+        drop_while: {
+          dropWhile: typeof import('./arkhe/array/drop-while')['dropWhile'];
+        };
+        fill: {
+          fill: typeof import('./arkhe/array/fill')['fill'];
+        };
+        find_best: {
+          findBest: typeof import('./arkhe/array/find-best')['findBest'];
+        };
+        find_last: {
+          findLast: typeof import('./arkhe/array/find-last')['findLast'];
+        };
+        find_last_index: {
+          findLastIndex: typeof import('./arkhe/array/find-last-index')['findLastIndex'];
+        };
+        group_by: {
+          groupBy: typeof import('./arkhe/array/group-by')['groupBy'];
+        };
+        group_with: {
+          groupWith: typeof import('./arkhe/array/group-with')['groupWith'];
+        };
+        intersection: {
+          intersection: typeof import('./arkhe/array/intersection')['intersection'];
+        };
+        intersection_by: {
+          intersectionBy: typeof import('./arkhe/array/intersection-by')['intersectionBy'];
+        };
+        intersection_with: {
+          intersectionWith: typeof import('./arkhe/array/intersection-with')['intersectionWith'];
+        };
+        key_by: {
+          keyBy: typeof import('./arkhe/array/key-by')['keyBy'];
+        };
+        max_by: {
+          maxBy: typeof import('./arkhe/array/max-by')['maxBy'];
+        };
+        min_by: {
+          minBy: typeof import('./arkhe/array/min-by')['minBy'];
+        };
+        order_by: {
+          orderBy: typeof import('./arkhe/array/order-by')['orderBy'];
+        };
+        partition: {
+          partition: typeof import('./arkhe/array/partition')['partition'];
+        };
+        reverse: {
+          reverse: typeof import('./arkhe/array/reverse')['reverse'];
+        };
+        sample: {
+          sample: typeof import('./arkhe/array/sample')['sample'];
+        };
+        sample_size: {
+          sampleSize: typeof import('./arkhe/array/sample-size')['sampleSize'];
+        };
+        shuffle: {
+          shuffle: typeof import('./arkhe/array/shuffle')['shuffle'];
+        };
+        take: {
+          take: typeof import('./arkhe/array/take')['take'];
+        };
+        take_right: {
+          takeRight: typeof import('./arkhe/array/take-right')['takeRight'];
+        };
+        take_right_while: {
+          takeRightWhile: typeof import('./arkhe/array/take-right-while')['takeRightWhile'];
+        };
+        take_while: {
+          takeWhile: typeof import('./arkhe/array/take-while')['takeWhile'];
+        };
+        to_array: {
+          toArray: typeof import('./arkhe/array/to-array')['toArray'];
+        };
+        toggle: {
+          toggle: typeof import('./arkhe/array/toggle')['toggle'];
+        };
+        union: {
+          union: typeof import('./arkhe/array/union')['union'];
+        };
+        union_by: {
+          unionBy: typeof import('./arkhe/array/union-by')['unionBy'];
+        };
+        union_with: {
+          unionWith: typeof import('./arkhe/array/union-with')['unionWith'];
+        };
+        uniq: {
+          uniq: typeof import('./arkhe/array/uniq')['uniq'];
+        };
+        uniq_by: {
+          uniqBy: typeof import('./arkhe/array/uniq-by')['uniqBy'];
+        };
+        uniq_with: {
+          uniqWith: typeof import('./arkhe/array/uniq-with')['uniqWith'];
+        };
+        unzip: {
+          unzip: typeof import('./arkhe/array/unzip')['unzip'];
+        };
+        window: {
+          window: typeof import('./arkhe/array/window')['window'];
+        };
+        xor: {
+          xor: typeof import('./arkhe/array/xor')['xor'];
+        };
+        zip: {
+          zip: typeof import('./arkhe/array/zip')['zip'];
+        };
+        zip_with: {
+          zipWith: typeof import('./arkhe/array/zip-with')['zipWith'];
+        };
+        all: {
+          all: typeof import('./arkhe/async/all')['all'];
+        };
+        dedupe_by_key: {
+          dedupeByKey: typeof import('./arkhe/async/dedupe-by-key')['dedupeByKey'];
+        };
+        defer: {
+          defer: typeof import('./arkhe/async/defer')['defer'];
+        };
+        guard: {
+          guard: typeof import('./arkhe/async/guard')['guard'];
+        };
+        parallel: {
+          parallel: typeof import('./arkhe/async/parallel')['parallel'];
+        };
+        queue_by_key: {
+          queueByKey: typeof import('./arkhe/async/queue-by-key')['queueByKey'];
+        };
+        retry: {
+          retry: typeof import('./arkhe/async/retry')['retry'];
+        };
+        after: {
+          after: typeof import('./arkhe/function/after')['after'];
+        };
+        before: {
+          before: typeof import('./arkhe/function/before')['before'];
+        };
+        cast_comparator: {
+          castComparator: typeof import('./arkhe/function/cast-comparator')['castComparator'];
+        };
+        cast_mapping: {
+          castMapping: typeof import('./arkhe/function/cast-mapping')['castMapping'];
+        };
+        curry: {
+          curry: typeof import('./arkhe/function/curry')['curry'];
+        };
+        debounce: {
+          debounce: typeof import('./arkhe/function/debounce')['debounce'];
+        };
+        flip: {
+          flip: typeof import('./arkhe/function/flip')['flip'];
+        };
+        flow_right: {
+          compose: typeof import('./arkhe/function/flow-right')['compose'];
+          flowRight: typeof import('./arkhe/function/flow-right')['flowRight'];
+        };
+        memoize: {
+          memoize: typeof import('./arkhe/function/memoize')['memoize'];
+        };
+        negate: {
+          negate: typeof import('./arkhe/function/negate')['negate'];
+        };
+        noop: {
+          noop: typeof import('./arkhe/function/noop')['noop'];
+        };
+        once: {
+          once: typeof import('./arkhe/function/once')['once'];
+        };
+        pipe: {
+          pipe: typeof import('./arkhe/function/pipe')['pipe'];
+        };
+        throttle: {
+          throttle: typeof import('./arkhe/function/throttle')['throttle'];
+        };
+        unless: {
+          unless: typeof import('./arkhe/function/unless')['unless'];
+        };
+        when: {
+          when: typeof import('./arkhe/function/when')['when'];
+        };
+        clamp: {
+          clamp: typeof import('./arkhe/number/clamp')['clamp'];
+        };
+        in_range: {
+          inRange: typeof import('./arkhe/number/in-range')['inRange'];
+        };
+        parsers: {
+          parse_float_def: {
+            parseFloatDef: typeof import('./arkhe/number/parsers/parse-float-def')['parseFloatDef'];
+          };
+          parse_float: {
+            parseFloat: typeof import('./arkhe/number/parsers/parse-float')['parseFloat'];
+          };
+          parse_int_def: {
+            parseIntDef: typeof import('./arkhe/number/parsers/parse-int-def')['parseIntDef'];
+          };
+        };
+        random: {
+          random: typeof import('./arkhe/number/random')['random'];
+        };
+        to_number: {
+          toNumber: typeof import('./arkhe/number/to-number')['toNumber'];
+        };
+        deep_clone: {
+          deepClone: typeof import('./arkhe/object/deep-clone')['deepClone'];
+        };
+        deep_clone_full: {
+          deepCloneFull: typeof import('./arkhe/object/deep-clone-full')['deepCloneFull'];
+        };
+        defaults: {
+          defaults: typeof import('./arkhe/object/defaults')['defaults'];
+        };
+        defaults_deep: {
+          defaultsDeep: typeof import('./arkhe/object/defaults-deep')['defaultsDeep'];
+        };
+        evolve: {
+          evolve: typeof import('./arkhe/object/evolve')['evolve'];
+        };
+        find_key: {
+          findKey: typeof import('./arkhe/object/find-key')['findKey'];
+        };
+        get: {
+          get: typeof import('./arkhe/object/get')['get'];
+        };
+        has: {
+          has: typeof import('./arkhe/object/has')['has'];
+        };
+        invert: {
+          invert: typeof import('./arkhe/object/invert')['invert'];
+        };
+        map_keys: {
+          mapKeys: typeof import('./arkhe/object/map-keys')['mapKeys'];
+        };
+        map_values: {
+          mapValues: typeof import('./arkhe/object/map-values')['mapValues'];
+        };
+        merge_deep: {
+          mergeDeepLeft: typeof import('./arkhe/object/merge-deep')['mergeDeepLeft'];
+          mergeDeepRight: typeof import('./arkhe/object/merge-deep')['mergeDeepRight'];
+        };
+        merge_with: {
+          mergeWith: typeof import('./arkhe/object/merge-with')['mergeWith'];
+        };
+        omit: {
+          omit: typeof import('./arkhe/object/omit')['omit'];
+        };
+        omit_by: {
+          omitBy: typeof import('./arkhe/object/omit-by')['omitBy'];
+        };
+        pick: {
+          pick: typeof import('./arkhe/object/pick')['pick'];
+        };
+        pickBy: {
+          pickBy: typeof import('./arkhe/object/pickBy')['pickBy'];
+        };
+        set: {
+          set: typeof import('./arkhe/object/set')['set'];
+        };
+        camel_case: {
+          camelCase: typeof import('./arkhe/string/camel-case')['camelCase'];
+        };
+        capitalize: {
+          capitalize: typeof import('./arkhe/string/capitalize')['capitalize'];
+        };
+        constant_case: {
+          constantCase: typeof import('./arkhe/string/constant-case')['constantCase'];
+        };
+        deburr: {
+          deburr: typeof import('./arkhe/string/deburr')['deburr'];
+        };
+        escape: {
+          escape: typeof import('./arkhe/string/escape')['escape'];
+        };
+        escape_regexp: {
+          escapeRegExp: typeof import('./arkhe/string/escape-regexp')['escapeRegExp'];
+        };
+        kebab_case: {
+          kebabCase: typeof import('./arkhe/string/kebab-case')['kebabCase'];
+        };
+        lower_case: {
+          lowerCase: typeof import('./arkhe/string/lower-case')['lowerCase'];
+        };
+        lowerFirst: {
+          lowerFirst: typeof import('./arkhe/string/lowerFirst')['lowerFirst'];
+        };
+        parsers: {
+          parse_comma_separated: {
+            parseCommaSeparated: typeof import('./arkhe/string/parsers/parse-comma-separated')['parseCommaSeparated'];
+          };
+          parse_key_value_pairs: {
+            parseKeyValuePairs: typeof import('./arkhe/string/parsers/parse-key-value-pairs')['parseKeyValuePairs'];
+          };
+          path_parser: {
+            parsePath: typeof import('./arkhe/string/parsers/path-parser')['parsePath'];
+          };
+        };
+        pascal_case: {
+          pascalCase: typeof import('./arkhe/string/pascal-case')['pascalCase'];
+        };
+        sentence_case: {
+          sentenceCase: typeof import('./arkhe/string/sentence-case')['sentenceCase'];
+        };
+        snake_case: {
+          snakeCase: typeof import('./arkhe/string/snake-case')['snakeCase'];
+        };
+        template: {
+          template: typeof import('./arkhe/string/template')['template'];
+        };
+        title_case: {
+          titleCase: typeof import('./arkhe/string/title-case')['titleCase'];
+        };
+        truncate: {
+          truncate: typeof import('./arkhe/string/truncate')['truncate'];
+        };
+        unescape: {
+          unescape: typeof import('./arkhe/string/unescape')['unescape'];
+        };
+        uniq_with: {
+          uniqWith: typeof import('./arkhe/string/uniq-with')['uniqWith'];
+        };
+        upper_case: {
+          upperCase: typeof import('./arkhe/string/upper-case')['upperCase'];
+        };
+        words: {
+          words: typeof import('./arkhe/string/words')['words'];
+        };
+        console: {
+          mockConsole: typeof import('./arkhe/test/console')['mockConsole'];
+          silenceConsole: typeof import('./arkhe/test/console')['silenceConsole'];
+          withSilentConsole: typeof import('./arkhe/test/console')['withSilentConsole'];
+        };
+        globals: {
+          __autoRestoreAll: typeof import('./arkhe/test/globals')['__autoRestoreAll'];
+          getGlobalThis: typeof import('./arkhe/test/globals')['getGlobalThis'];
+          mockDocument: typeof import('./arkhe/test/globals')['mockDocument'];
+          mockDOMRect: typeof import('./arkhe/test/globals')['mockDOMRect'];
+          mockPerformance: typeof import('./arkhe/test/globals')['mockPerformance'];
+          mockWindow: typeof import('./arkhe/test/globals')['mockWindow'];
+          setGlobal: typeof import('./arkhe/test/globals')['setGlobal'];
+          trackRestore: typeof import('./arkhe/test/globals')['trackRestore'];
+        };
+        private_access: {
+          cast: typeof import('./arkhe/test/private-access')['cast'];
+          castArray: typeof import('./arkhe/test/private-access')['castArray'];
+          castMap: typeof import('./arkhe/test/private-access')['castMap'];
+          testNull: typeof import('./arkhe/test/private-access')['testNull'];
+          testUndefined: typeof import('./arkhe/test/private-access')['testUndefined'];
+        };
+        default_to: {
+          defaultTo: typeof import('./arkhe/util/default-to')['defaultTo'];
+        };
+        range: {
+          range: typeof import('./arkhe/util/range')['range'];
+        };
+        sleep: {
+          sleep: typeof import('./arkhe/util/sleep')['sleep'];
+        };
+        times: {
+          times: typeof import('./arkhe/util/times')['times'];
+        };
+        unique_id: {
+          uniqueId: typeof import('./arkhe/util/unique-id')['uniqueId'];
+        };
+        guard: {
+          is_array_buffer: {
+            isArrayBuffer: typeof import('./arkhe/is/guard/is-array-buffer')['isArrayBuffer'];
+          };
+          is_array: {
+            isArray: typeof import('./arkhe/is/guard/is-array')['isArray'];
+          };
+          is_bigint: {
+            isBigint: typeof import('./arkhe/is/guard/is-bigint')['isBigint'];
+          };
+          is_boolean: {
+            isBoolean: typeof import('./arkhe/is/guard/is-boolean')['isBoolean'];
+          };
+          is_date: {
+            isDate: typeof import('./arkhe/is/guard/is-date')['isDate'];
+          };
+          is_error: {
+            isError: typeof import('./arkhe/is/guard/is-error')['isError'];
+          };
+          is_function: {
+            isFunction: typeof import('./arkhe/is/guard/is-function')['isFunction'];
+          };
+          is_map: {
+            isMap: typeof import('./arkhe/is/guard/is-map')['isMap'];
+          };
+          is_nil: {
+            isNil: typeof import('./arkhe/is/guard/is-nil')['isNil'];
+          };
+          is_non_null: {
+            isNonNull: typeof import('./arkhe/is/guard/is-non-null')['isNonNull'];
+          };
+          is_non_nullable: {
+            isNonNullable: typeof import('./arkhe/is/guard/is-non-nullable')['isNonNullable'];
+          };
+          is_non_undefined: {
+            isNonUndefined: typeof import('./arkhe/is/guard/is-non-undefined')['isNonUndefined'];
+          };
+          is_null: {
+            isNull: typeof import('./arkhe/is/guard/is-null')['isNull'];
+          };
+          is_number: {
+            isNumber: typeof import('./arkhe/is/guard/is-number')['isNumber'];
+          };
+          is_object: {
+            isObject: typeof import('./arkhe/is/guard/is-object')['isObject'];
+          };
+          is_one_of: {
+            isOneOf: typeof import('./arkhe/is/guard/is-one-of')['isOneOf'];
+          };
+          is_plain_object: {
+            isPlainObject: typeof import('./arkhe/is/guard/is-plain-object')['isPlainObject'];
+          };
+          is_primitive: {
+            isPrimitive: typeof import('./arkhe/is/guard/is-primitive')['isPrimitive'];
+          };
+          is_promise: {
+            isPromise: typeof import('./arkhe/is/guard/is-promise')['isPromise'];
+          };
+          is_regexp: {
+            isRegExp: typeof import('./arkhe/is/guard/is-regexp')['isRegExp'];
+          };
+          is_set: {
+            isSet: typeof import('./arkhe/is/guard/is-set')['isSet'];
+          };
+          is_string: {
+            isString: typeof import('./arkhe/is/guard/is-string')['isString'];
+          };
+          is_symbol: {
+            isSymbol: typeof import('./arkhe/is/guard/is-symbol')['isSymbol'];
+          };
+          is_undefined: {
+            isUndefined: typeof import('./arkhe/is/guard/is-undefined')['isUndefined'];
+          };
+        };
+        predicate: {
+          is_empty: {
+            isEmpty: typeof import('./arkhe/is/predicate/is-empty')['isEmpty'];
+          };
+          is_equal: {
+            isEqual: typeof import('./arkhe/is/predicate/is-equal')['isEqual'];
+          };
+          is_float: {
+            isFloat: typeof import('./arkhe/is/predicate/is-float')['isFloat'];
+          };
+        };
+        animations: {
+          easing: {
+          };
+        };
+        common: {
+          arrayable: {
+          };
+          awaitable: {
+          };
+          nullish: {
+          };
+        };
+        dom: {
+          attachable: {
+          };
+          viewport: {
+          };
+        };
+        gestures: {
+          axis: {
+          };
+          drag: {
+          };
+        };
+        math: {
+          arithmetic: {
+          };
+          geometry: {
+          };
+        };
+        performance: {
+          cache: {
+          };
+        };
+        utilities: {
+          deep_partial: {
+          };
+          deep_readonly: {
+          };
+          entry: {
+          };
+          error_type: {
+          };
+          is_some_option: {
+            isSomeOption: typeof import('./arkhe/types/utilities/is-some-option')['isSomeOption'];
+          };
+          map_entries: {
+          };
+          non_empty_array: {
+          };
+          partial_except: {
+          };
+          partial_keys: {
+          };
+          prettify: {
+          };
+          primitive: {
+          };
+          required_except: {
+          };
+          required_keys: {
+          };
+          strict_omit: {
+          };
+        };
+  };
+  kanon: {
+    index: {
+      any: typeof import('./kanon/index')['any'];
+      array: typeof import('./kanon/index')['array'];
+      bigint: typeof import('./kanon/index')['bigint'];
+      boolean: typeof import('./kanon/index')['boolean'];
+      booleanEnum: typeof import('./kanon/index')['booleanEnum'];
+      clearCache: typeof import('./kanon/index')['clearCache'];
+      coerceBigInt: typeof import('./kanon/index')['coerceBigInt'];
+      coerceBoolean: typeof import('./kanon/index')['coerceBoolean'];
+      coerceDate: typeof import('./kanon/index')['coerceDate'];
+      coerceNumber: typeof import('./kanon/index')['coerceNumber'];
+      coerceString: typeof import('./kanon/index')['coerceString'];
+      compile: typeof import('./kanon/index')['compile'];
+      date: typeof import('./kanon/index')['date'];
+      default_: typeof import('./kanon/index')['default_'];
+      DefaultValues: typeof import('./kanon/index')['DefaultValues'];
+      discriminatedUnion: typeof import('./kanon/index')['discriminatedUnion'];
+      enum_: typeof import('./kanon/index')['enum_'];
+      hasTupleRest: typeof import('./kanon/index')['hasTupleRest'];
+      int: typeof import('./kanon/index')['int'];
+      intersection: typeof import('./kanon/index')['intersection'];
+      intersection3: typeof import('./kanon/index')['intersection3'];
+      isArrayConstraint: typeof import('./kanon/index')['isArrayConstraint'];
+      isBigIntConstraint: typeof import('./kanon/index')['isBigIntConstraint'];
+      isDateConstraint: typeof import('./kanon/index')['isDateConstraint'];
+      isJITAvailable: typeof import('./kanon/index')['isJITAvailable'];
+      isMapConstraint: typeof import('./kanon/index')['isMapConstraint'];
+      isNumberConstraint: typeof import('./kanon/index')['isNumberConstraint'];
+      isObjectConstraint: typeof import('./kanon/index')['isObjectConstraint'];
+      isSchemaType: typeof import('./kanon/index')['isSchemaType'];
+      isSetConstraint: typeof import('./kanon/index')['isSetConstraint'];
+      isStringConstraint: typeof import('./kanon/index')['isStringConstraint'];
+      k: typeof import('./kanon/index')['k'];
+      keyof: typeof import('./kanon/index')['keyof'];
+      lazy: typeof import('./kanon/index')['lazy'];
+      literal: typeof import('./kanon/index')['literal'];
+      looseObject: typeof import('./kanon/index')['looseObject'];
+      map: typeof import('./kanon/index')['map'];
+      mixedEnum: typeof import('./kanon/index')['mixedEnum'];
+      nativeEnum: typeof import('./kanon/index')['nativeEnum'];
+      never: typeof import('./kanon/index')['never'];
+      null_: typeof import('./kanon/index')['null_'];
+      nullable: typeof import('./kanon/index')['nullable'];
+      nullish: typeof import('./kanon/index')['nullish'];
+      number: typeof import('./kanon/index')['number'];
+      numberEnum: typeof import('./kanon/index')['numberEnum'];
+      object: typeof import('./kanon/index')['object'];
+      omit: typeof import('./kanon/index')['omit'];
+      optional: typeof import('./kanon/index')['optional'];
+      parse: typeof import('./kanon/index')['parse'];
+      parseBulk: typeof import('./kanon/index')['parseBulk'];
+      partial: typeof import('./kanon/index')['partial'];
+      pick: typeof import('./kanon/index')['pick'];
+      readonly: typeof import('./kanon/index')['readonly'];
+      record: typeof import('./kanon/index')['record'];
+      required: typeof import('./kanon/index')['required'];
+      schemaGuards: typeof import('./kanon/index')['schemaGuards'];
+      set: typeof import('./kanon/index')['set'];
+      strictObject: typeof import('./kanon/index')['strictObject'];
+      string: typeof import('./kanon/index')['string'];
+      symbol: typeof import('./kanon/index')['symbol'];
+      tuple: typeof import('./kanon/index')['tuple'];
+      tupleOf: typeof import('./kanon/index')['tupleOf'];
+      tupleOf3: typeof import('./kanon/index')['tupleOf3'];
+      tupleOf4: typeof import('./kanon/index')['tupleOf4'];
+      tupleWithRest: typeof import('./kanon/index')['tupleWithRest'];
+      undefined_: typeof import('./kanon/index')['undefined_'];
+      unionOf: typeof import('./kanon/index')['unionOf'];
+      unionOf3: typeof import('./kanon/index')['unionOf3'];
+      unionOf4: typeof import('./kanon/index')['unionOf4'];
+      unknown: typeof import('./kanon/index')['unknown'];
+      validation: typeof import('./kanon/index')['validation'];
+      void_: typeof import('./kanon/index')['void_'];
+    };
+    validation: {
+      validation: typeof import('./kanon/validation')['validation'];
+    };
+        consts: {
+          messages: {
+            ERROR_MESSAGES_COMPOSITION: typeof import('./kanon/core/consts/messages')['ERROR_MESSAGES_COMPOSITION'];
+          };
+          patterns: {
+            EMAIL_REGEX: typeof import('./kanon/core/consts/patterns')['EMAIL_REGEX'];
+            URL_REGEX: typeof import('./kanon/core/consts/patterns')['URL_REGEX'];
+            UUID_REGEX: typeof import('./kanon/core/consts/patterns')['UUID_REGEX'];
+          };
+        };
+        parser: {
+          parse: typeof import('./kanon/core/parser')['parse'];
+          parseBulk: typeof import('./kanon/core/parser')['parseBulk'];
+        };
+        as_zod: {
+          asZod: typeof import('./kanon/helpers/as-zod')['asZod'];
+        };
+        as_zod.shim: {
+          z: typeof import('./kanon/helpers/as-zod.shim')['z'];
+        };
+        k: {
+          k: typeof import('./kanon/helpers/k')['k'];
+        };
+        builders: {
+          coerce: {
+            generateCoerceBooleanCheck: typeof import('./kanon/jit/builders/coerce')['generateCoerceBooleanCheck'];
+            generateCoerceBooleanValidation: typeof import('./kanon/jit/builders/coerce')['generateCoerceBooleanValidation'];
+            generateCoerceDateCheck: typeof import('./kanon/jit/builders/coerce')['generateCoerceDateCheck'];
+            generateCoerceDateValidation: typeof import('./kanon/jit/builders/coerce')['generateCoerceDateValidation'];
+            generateCoerceNumberCheck: typeof import('./kanon/jit/builders/coerce')['generateCoerceNumberCheck'];
+            generateCoerceNumberValidation: typeof import('./kanon/jit/builders/coerce')['generateCoerceNumberValidation'];
+            generateCoerceStringCheck: typeof import('./kanon/jit/builders/coerce')['generateCoerceStringCheck'];
+            generateCoerceStringValidation: typeof import('./kanon/jit/builders/coerce')['generateCoerceStringValidation'];
+            isCoerceType: typeof import('./kanon/jit/builders/coerce')['isCoerceType'];
+          };
+          refinements: {
+            generateRefinementCall: typeof import('./kanon/jit/builders/refinements')['generateRefinementCall'];
+            generateRefinementsValidation: typeof import('./kanon/jit/builders/refinements')['generateRefinementsValidation'];
+            getRefinements: typeof import('./kanon/jit/builders/refinements')['getRefinements'];
+            hasRefinements: typeof import('./kanon/jit/builders/refinements')['hasRefinements'];
+          };
+                  array: {
+                    generateArrayItemsLoop: typeof import('./kanon/jit/builders/composites/array')['generateArrayItemsLoop'];
+                    generateArrayLengthCheck: typeof import('./kanon/jit/builders/composites/array')['generateArrayLengthCheck'];
+                    generateArrayMaxLengthCheck: typeof import('./kanon/jit/builders/composites/array')['generateArrayMaxLengthCheck'];
+                    generateArrayMinLengthCheck: typeof import('./kanon/jit/builders/composites/array')['generateArrayMinLengthCheck'];
+                    generateArrayTypeCheck: typeof import('./kanon/jit/builders/composites/array')['generateArrayTypeCheck'];
+                    generateArrayValidation: typeof import('./kanon/jit/builders/composites/array')['generateArrayValidation'];
+                    generateSimpleArrayItemsLoop: typeof import('./kanon/jit/builders/composites/array')['generateSimpleArrayItemsLoop'];
+                  };
+                  object: {
+                    createNestedObjectGenerator: typeof import('./kanon/jit/builders/composites/object')['createNestedObjectGenerator'];
+                    generateMaxKeysCheck: typeof import('./kanon/jit/builders/composites/object')['generateMaxKeysCheck'];
+                    generateMinKeysCheck: typeof import('./kanon/jit/builders/composites/object')['generateMinKeysCheck'];
+                    generateObjectTypeCheck: typeof import('./kanon/jit/builders/composites/object')['generateObjectTypeCheck'];
+                    generateObjectValidation: typeof import('./kanon/jit/builders/composites/object')['generateObjectValidation'];
+                    generatePropertyValidation: typeof import('./kanon/jit/builders/composites/object')['generatePropertyValidation'];
+                    generateStrictModeCheck: typeof import('./kanon/jit/builders/composites/object')['generateStrictModeCheck'];
+                  };
+                  union: {
+                    canOptimizeWithTypeof: typeof import('./kanon/jit/builders/operators/union')['canOptimizeWithTypeof'];
+                    createBooleanBranch: typeof import('./kanon/jit/builders/operators/union')['createBooleanBranch'];
+                    createNullBranch: typeof import('./kanon/jit/builders/operators/union')['createNullBranch'];
+                    createNumberBranch: typeof import('./kanon/jit/builders/operators/union')['createNumberBranch'];
+                    createStringBranch: typeof import('./kanon/jit/builders/operators/union')['createStringBranch'];
+                    createUndefinedBranch: typeof import('./kanon/jit/builders/operators/union')['createUndefinedBranch'];
+                    generateOptimizedPrimitiveUnion: typeof import('./kanon/jit/builders/operators/union')['generateOptimizedPrimitiveUnion'];
+                    generateSimpleSequentialUnion: typeof import('./kanon/jit/builders/operators/union')['generateSimpleSequentialUnion'];
+                    generateUnionValidation: typeof import('./kanon/jit/builders/operators/union')['generateUnionValidation'];
+                    groupBranchesByTypeof: typeof import('./kanon/jit/builders/operators/union')['groupBranchesByTypeof'];
+                  };
+                  boolean: {
+                    generateBooleanTypeCheck: typeof import('./kanon/jit/builders/primitives/boolean')['generateBooleanTypeCheck'];
+                    generateBooleanValidation: typeof import('./kanon/jit/builders/primitives/boolean')['generateBooleanValidation'];
+                  };
+                  number: {
+                    generateGtCheck: typeof import('./kanon/jit/builders/primitives/number')['generateGtCheck'];
+                    generateGteCheck: typeof import('./kanon/jit/builders/primitives/number')['generateGteCheck'];
+                    generateIntCheck: typeof import('./kanon/jit/builders/primitives/number')['generateIntCheck'];
+                    generateLtCheck: typeof import('./kanon/jit/builders/primitives/number')['generateLtCheck'];
+                    generateLteCheck: typeof import('./kanon/jit/builders/primitives/number')['generateLteCheck'];
+                    generateMaxCheck: typeof import('./kanon/jit/builders/primitives/number')['generateMaxCheck'];
+                    generateMinCheck: typeof import('./kanon/jit/builders/primitives/number')['generateMinCheck'];
+                    generateMultipleOfCheck: typeof import('./kanon/jit/builders/primitives/number')['generateMultipleOfCheck'];
+                    generateNegativeCheck: typeof import('./kanon/jit/builders/primitives/number')['generateNegativeCheck'];
+                    generateNumberTypeCheck: typeof import('./kanon/jit/builders/primitives/number')['generateNumberTypeCheck'];
+                    generateNumberValidation: typeof import('./kanon/jit/builders/primitives/number')['generateNumberValidation'];
+                    generatePositiveCheck: typeof import('./kanon/jit/builders/primitives/number')['generatePositiveCheck'];
+                  };
+                  others: {
+                    generateAnyValidation: typeof import('./kanon/jit/builders/primitives/others')['generateAnyValidation'];
+                    generateNeverTypeCheck: typeof import('./kanon/jit/builders/primitives/others')['generateNeverTypeCheck'];
+                    generateNeverValidation: typeof import('./kanon/jit/builders/primitives/others')['generateNeverValidation'];
+                    generateNullTypeCheck: typeof import('./kanon/jit/builders/primitives/others')['generateNullTypeCheck'];
+                    generateNullValidation: typeof import('./kanon/jit/builders/primitives/others')['generateNullValidation'];
+                    generateSymbolTypeCheck: typeof import('./kanon/jit/builders/primitives/others')['generateSymbolTypeCheck'];
+                    generateSymbolValidation: typeof import('./kanon/jit/builders/primitives/others')['generateSymbolValidation'];
+                    generateUndefinedTypeCheck: typeof import('./kanon/jit/builders/primitives/others')['generateUndefinedTypeCheck'];
+                    generateUndefinedValidation: typeof import('./kanon/jit/builders/primitives/others')['generateUndefinedValidation'];
+                    generateUnknownValidation: typeof import('./kanon/jit/builders/primitives/others')['generateUnknownValidation'];
+                    generateVoidTypeCheck: typeof import('./kanon/jit/builders/primitives/others')['generateVoidTypeCheck'];
+                    generateVoidValidation: typeof import('./kanon/jit/builders/primitives/others')['generateVoidValidation'];
+                  };
+                  string: {
+                    generateEmailCheck: typeof import('./kanon/jit/builders/primitives/string')['generateEmailCheck'];
+                    generateEndsWithCheck: typeof import('./kanon/jit/builders/primitives/string')['generateEndsWithCheck'];
+                    generateIncludesCheck: typeof import('./kanon/jit/builders/primitives/string')['generateIncludesCheck'];
+                    generateLengthCheck: typeof import('./kanon/jit/builders/primitives/string')['generateLengthCheck'];
+                    generateMaxLengthCheck: typeof import('./kanon/jit/builders/primitives/string')['generateMaxLengthCheck'];
+                    generateMinLengthCheck: typeof import('./kanon/jit/builders/primitives/string')['generateMinLengthCheck'];
+                    generateRegexCheck: typeof import('./kanon/jit/builders/primitives/string')['generateRegexCheck'];
+                    generateStartsWithCheck: typeof import('./kanon/jit/builders/primitives/string')['generateStartsWithCheck'];
+                    generateStringTypeCheck: typeof import('./kanon/jit/builders/primitives/string')['generateStringTypeCheck'];
+                    generateStringValidation: typeof import('./kanon/jit/builders/primitives/string')['generateStringValidation'];
+                    generateUrlCheck: typeof import('./kanon/jit/builders/primitives/string')['generateUrlCheck'];
+                    generateUuidCheck: typeof import('./kanon/jit/builders/primitives/string')['generateUuidCheck'];
+                    STRING_PATTERNS: typeof import('./kanon/jit/builders/primitives/string')['STRING_PATTERNS'];
+                  };
+        };
+        cache: {
+          createValidatorCache: typeof import('./kanon/jit/cache')['createValidatorCache'];
+          globalValidatorCache: typeof import('./kanon/jit/cache')['globalValidatorCache'];
+        };
+        compiler: {
+          clearCache: typeof import('./kanon/jit/compiler')['clearCache'];
+          compile: typeof import('./kanon/jit/compiler')['compile'];
+          isJITAvailable: typeof import('./kanon/jit/compiler')['isJITAvailable'];
+        };
+        context: {
+          addExternal: typeof import('./kanon/jit/context')['addExternal'];
+          createGeneratorContext: typeof import('./kanon/jit/context')['createGeneratorContext'];
+          decreaseIndent: typeof import('./kanon/jit/context')['decreaseIndent'];
+          formatPath: typeof import('./kanon/jit/context')['formatPath'];
+          getIndent: typeof import('./kanon/jit/context')['getIndent'];
+          hasVisited: typeof import('./kanon/jit/context')['hasVisited'];
+          increaseIndent: typeof import('./kanon/jit/context')['increaseIndent'];
+          markVisited: typeof import('./kanon/jit/context')['markVisited'];
+          nextVar: typeof import('./kanon/jit/context')['nextVar'];
+          popPath: typeof import('./kanon/jit/context')['popPath'];
+          pushPath: typeof import('./kanon/jit/context')['pushPath'];
+        };
+        utils: {
+          arbitraries: {
+            arbitraryArraySchema: typeof import('./kanon/jit/utils/arbitraries')['arbitraryArraySchema'];
+            arbitraryBooleanSchema: typeof import('./kanon/jit/utils/arbitraries')['arbitraryBooleanSchema'];
+            arbitraryNumberSchema: typeof import('./kanon/jit/utils/arbitraries')['arbitraryNumberSchema'];
+            arbitraryObjectSchema: typeof import('./kanon/jit/utils/arbitraries')['arbitraryObjectSchema'];
+            arbitrarySchema: typeof import('./kanon/jit/utils/arbitraries')['arbitrarySchema'];
+            arbitrarySchemaWithInvalidValue: typeof import('./kanon/jit/utils/arbitraries')['arbitrarySchemaWithInvalidValue'];
+            arbitrarySchemaWithValidValue: typeof import('./kanon/jit/utils/arbitraries')['arbitrarySchemaWithValidValue'];
+            arbitrarySchemaWithValue: typeof import('./kanon/jit/utils/arbitraries')['arbitrarySchemaWithValue'];
+            arbitraryStringSchema: typeof import('./kanon/jit/utils/arbitraries')['arbitraryStringSchema'];
+            arbitraryUnionSchema: typeof import('./kanon/jit/utils/arbitraries')['arbitraryUnionSchema'];
+            arbitraryValueForSchema: typeof import('./kanon/jit/utils/arbitraries')['arbitraryValueForSchema'];
+          };
+          code: {
+            debugComment: typeof import('./kanon/jit/utils/code')['debugComment'];
+            debugSectionComment: typeof import('./kanon/jit/utils/code')['debugSectionComment'];
+            escapeString: typeof import('./kanon/jit/utils/code')['escapeString'];
+            wrapWithDebugComment: typeof import('./kanon/jit/utils/code')['wrapWithDebugComment'];
+          };
+        };
+        base: {
+          isCoerced: typeof import('./kanon/types/base')['isCoerced'];
+        };
+        composites: {
+          hasTupleRest: typeof import('./kanon/types/composites')['hasTupleRest'];
+        };
+        constraints: {
+        };
+        guards: {
+          isArrayConstraint: typeof import('./kanon/types/guards')['isArrayConstraint'];
+          isBigIntConstraint: typeof import('./kanon/types/guards')['isBigIntConstraint'];
+          isDateConstraint: typeof import('./kanon/types/guards')['isDateConstraint'];
+          isMapConstraint: typeof import('./kanon/types/guards')['isMapConstraint'];
+          isNumberConstraint: typeof import('./kanon/types/guards')['isNumberConstraint'];
+          isObjectConstraint: typeof import('./kanon/types/guards')['isObjectConstraint'];
+          isSchemaType: typeof import('./kanon/types/guards')['isSchemaType'];
+          isSetConstraint: typeof import('./kanon/types/guards')['isSetConstraint'];
+          isStringConstraint: typeof import('./kanon/types/guards')['isStringConstraint'];
+          schemaGuards: typeof import('./kanon/types/guards')['schemaGuards'];
+        };
+        operators: {
+        };
+        primitives: {
+        };
+        transforms: {
+        };
+        wrappers: {
+        };
+        coerce: {
+          bigint: {
+            coerceBigInt: typeof import('./kanon/schemas/coerce/bigint')['coerceBigInt'];
+          };
+          boolean: {
+            coerceBoolean: typeof import('./kanon/schemas/coerce/boolean')['coerceBoolean'];
+          };
+          date: {
+            coerceDate: typeof import('./kanon/schemas/coerce/date')['coerceDate'];
+          };
+          number: {
+            coerceNumber: typeof import('./kanon/schemas/coerce/number')['coerceNumber'];
+          };
+          string: {
+            coerceString: typeof import('./kanon/schemas/coerce/string')['coerceString'];
+          };
+        };
+        composites: {
+          array: {
+            array: typeof import('./kanon/schemas/composites/array')['array'];
+          };
+          map: {
+            map: typeof import('./kanon/schemas/composites/map')['map'];
+          };
+          object: {
+            looseObject: typeof import('./kanon/schemas/composites/object')['looseObject'];
+            object: typeof import('./kanon/schemas/composites/object')['object'];
+            strictObject: typeof import('./kanon/schemas/composites/object')['strictObject'];
+          };
+          record: {
+            record: typeof import('./kanon/schemas/composites/record')['record'];
+          };
+          set: {
+            set: typeof import('./kanon/schemas/composites/set')['set'];
+          };
+          tuple: {
+            tuple: typeof import('./kanon/schemas/composites/tuple')['tuple'];
+            tupleOf: typeof import('./kanon/schemas/composites/tuple')['tupleOf'];
+            tupleOf3: typeof import('./kanon/schemas/composites/tuple')['tupleOf3'];
+            tupleOf4: typeof import('./kanon/schemas/composites/tuple')['tupleOf4'];
+            tupleWithRest: typeof import('./kanon/schemas/composites/tuple')['tupleWithRest'];
+          };
+        };
+        constraints: {
+          array: {
+            addArrayConstraints: typeof import('./kanon/schemas/constraints/array')['addArrayConstraints'];
+          };
+          bigint: {
+            addBigIntConstraints: typeof import('./kanon/schemas/constraints/bigint')['addBigIntConstraints'];
+          };
+          date: {
+            addDateConstraints: typeof import('./kanon/schemas/constraints/date')['addDateConstraints'];
+          };
+          map: {
+            addMapConstraints: typeof import('./kanon/schemas/constraints/map')['addMapConstraints'];
+          };
+          number: {
+            addNumberConstraints: typeof import('./kanon/schemas/constraints/number')['addNumberConstraints'];
+          };
+          object: {
+            addObjectConstraints: typeof import('./kanon/schemas/constraints/object')['addObjectConstraints'];
+          };
+          set: {
+            addSetConstraints: typeof import('./kanon/schemas/constraints/set')['addSetConstraints'];
+          };
+          string: {
+            addStringConstraints: typeof import('./kanon/schemas/constraints/string')['addStringConstraints'];
+          };
+                  array: {
+                    refineArray: typeof import('./kanon/schemas/constraints/refine/array')['refineArray'];
+                  };
+                  bigint: {
+                    refineBigInt: typeof import('./kanon/schemas/constraints/refine/bigint')['refineBigInt'];
+                  };
+                  date: {
+                    refineDate: typeof import('./kanon/schemas/constraints/refine/date')['refineDate'];
+                  };
+                  map: {
+                    refineMap: typeof import('./kanon/schemas/constraints/refine/map')['refineMap'];
+                  };
+                  number: {
+                    refineNumber: typeof import('./kanon/schemas/constraints/refine/number')['refineNumber'];
+                  };
+                  object: {
+                    refineObject: typeof import('./kanon/schemas/constraints/refine/object')['refineObject'];
+                  };
+                  set: {
+                    refineSet: typeof import('./kanon/schemas/constraints/refine/set')['refineSet'];
+                  };
+                  string: {
+                    refineString: typeof import('./kanon/schemas/constraints/refine/string')['refineString'];
+                  };
+        };
+        operators: {
+          intersection: {
+            intersection: typeof import('./kanon/schemas/operators/intersection')['intersection'];
+            intersection3: typeof import('./kanon/schemas/operators/intersection')['intersection3'];
+          };
+          union: {
+            discriminatedUnion: typeof import('./kanon/schemas/operators/union')['discriminatedUnion'];
+            unionOf: typeof import('./kanon/schemas/operators/union')['unionOf'];
+            unionOf3: typeof import('./kanon/schemas/operators/union')['unionOf3'];
+            unionOf4: typeof import('./kanon/schemas/operators/union')['unionOf4'];
+          };
+        };
+        primitives: {
+          any: {
+            any: typeof import('./kanon/schemas/primitives/any')['any'];
+          };
+          bigint: {
+            bigint: typeof import('./kanon/schemas/primitives/bigint')['bigint'];
+          };
+          boolean: {
+            boolean: typeof import('./kanon/schemas/primitives/boolean')['boolean'];
+          };
+          date: {
+            date: typeof import('./kanon/schemas/primitives/date')['date'];
+          };
+          enum: {
+            booleanEnum: typeof import('./kanon/schemas/primitives/enum')['booleanEnum'];
+            enum_: typeof import('./kanon/schemas/primitives/enum')['enum_'];
+            mixedEnum: typeof import('./kanon/schemas/primitives/enum')['mixedEnum'];
+            numberEnum: typeof import('./kanon/schemas/primitives/enum')['numberEnum'];
+          };
+          int: {
+            int: typeof import('./kanon/schemas/primitives/int')['int'];
+          };
+          literal: {
+            literal: typeof import('./kanon/schemas/primitives/literal')['literal'];
+          };
+          nativeEnum: {
+            nativeEnum: typeof import('./kanon/schemas/primitives/nativeEnum')['nativeEnum'];
+          };
+          never: {
+            never: typeof import('./kanon/schemas/primitives/never')['never'];
+          };
+          null: {
+            null_: typeof import('./kanon/schemas/primitives/null')['null_'];
+          };
+          number: {
+            number: typeof import('./kanon/schemas/primitives/number')['number'];
+          };
+          string: {
+            string: typeof import('./kanon/schemas/primitives/string')['string'];
+          };
+          symbol: {
+            symbol: typeof import('./kanon/schemas/primitives/symbol')['symbol'];
+          };
+          undefined: {
+            undefined_: typeof import('./kanon/schemas/primitives/undefined')['undefined_'];
+          };
+          unknown: {
+            unknown: typeof import('./kanon/schemas/primitives/unknown')['unknown'];
+          };
+          void: {
+            void_: typeof import('./kanon/schemas/primitives/void')['void_'];
+          };
+        };
+        transforms: {
+          keyof: {
+            keyof: typeof import('./kanon/schemas/transforms/keyof')['keyof'];
+          };
+          omit: {
+            omit: typeof import('./kanon/schemas/transforms/omit')['omit'];
+          };
+          partial: {
+            partial: typeof import('./kanon/schemas/transforms/partial')['partial'];
+          };
+          pick: {
+            pick: typeof import('./kanon/schemas/transforms/pick')['pick'];
+          };
+          required: {
+            required: typeof import('./kanon/schemas/transforms/required')['required'];
+          };
+        };
+        wrappers: {
+          default: {
+            default_: typeof import('./kanon/schemas/wrappers/default')['default_'];
+            DefaultValues: typeof import('./kanon/schemas/wrappers/default')['DefaultValues'];
+          };
+          lazy: {
+            lazy: typeof import('./kanon/schemas/wrappers/lazy')['lazy'];
+          };
+          nullable: {
+            nullable: typeof import('./kanon/schemas/wrappers/nullable')['nullable'];
+          };
+          nullish: {
+            nullish: typeof import('./kanon/schemas/wrappers/nullish')['nullish'];
+          };
+          optional: {
+            optional: typeof import('./kanon/schemas/wrappers/optional')['optional'];
+          };
+          readonly: {
+            readonly: typeof import('./kanon/schemas/wrappers/readonly')['readonly'];
+          };
+        };
+  };
+  sphalma: {
+    error_factory: {
+      CodedError: typeof import('./sphalma/error-factory')['CodedError'];
+      createErrorFactory: typeof import('./sphalma/error-factory')['createErrorFactory'];
+    };
+  };
+  taphos: {
+        at: {
+          at: typeof import('./taphos/array/at')['at'];
+        };
+        compact: {
+          compact: typeof import('./taphos/array/compact')['compact'];
+        };
+        concat: {
+          concat: typeof import('./taphos/array/concat')['concat'];
+        };
+        find: {
+          find: typeof import('./taphos/array/find')['find'];
+        };
+        findIndex: {
+          findIndex: typeof import('./taphos/array/findIndex')['findIndex'];
+        };
+        first: {
+          first: typeof import('./taphos/array/first')['first'];
+        };
+        flatten: {
+          flatten: typeof import('./taphos/array/flatten')['flatten'];
+        };
+        flattenDeep: {
+          flattenDeep: typeof import('./taphos/array/flattenDeep')['flattenDeep'];
+        };
+        flattenDepth: {
+          flattenDepth: typeof import('./taphos/array/flattenDepth')['flattenDepth'];
+        };
+        fromPairs: {
+          fromPairs: typeof import('./taphos/array/fromPairs')['fromPairs'];
+        };
+        head: {
+          head: typeof import('./taphos/array/head')['head'];
+        };
+        indexOf: {
+          indexOf: typeof import('./taphos/array/indexOf')['indexOf'];
+        };
+        initial: {
+          initial: typeof import('./taphos/array/initial')['initial'];
+        };
+        join: {
+          join: typeof import('./taphos/array/join')['join'];
+        };
+        last: {
+          last: typeof import('./taphos/array/last')['last'];
+        };
+        lastIndexOf: {
+          lastIndexOf: typeof import('./taphos/array/lastIndexOf')['lastIndexOf'];
+        };
+        map: {
+          map: typeof import('./taphos/array/map')['map'];
+        };
+        nth: {
+          nth: typeof import('./taphos/array/nth')['nth'];
+        };
+        pull: {
+          pull: typeof import('./taphos/array/pull')['pull'];
+        };
+        pull_all: {
+          pullAll: typeof import('./taphos/array/pull-all')['pullAll'];
+        };
+        pullAllBy: {
+          pullAllBy: typeof import('./taphos/array/pullAllBy')['pullAllBy'];
+        };
+        pullAllWith: {
+          pullAllWith: typeof import('./taphos/array/pullAllWith')['pullAllWith'];
+        };
+        pullAt: {
+          pullAt: typeof import('./taphos/array/pullAt')['pullAt'];
+        };
+        remove: {
+          remove: typeof import('./taphos/array/remove')['remove'];
+        };
+        slice: {
+          slice: typeof import('./taphos/array/slice')['slice'];
+        };
+        tail: {
+          tail: typeof import('./taphos/array/tail')['tail'];
+        };
+        without: {
+          without: typeof import('./taphos/array/without')['without'];
+        };
+        zipObject: {
+          zipObject: typeof import('./taphos/array/zipObject')['zipObject'];
+        };
+        each: {
+          each: typeof import('./taphos/collection/each')['each'];
+        };
+        eachRight: {
+          eachRight: typeof import('./taphos/collection/eachRight')['eachRight'];
+          forEachRight: typeof import('./taphos/collection/eachRight')['forEachRight'];
+        };
+        every: {
+          every: typeof import('./taphos/collection/every')['every'];
+        };
+        filter: {
+          filter: typeof import('./taphos/collection/filter')['filter'];
+        };
+        flatMap: {
+          flatMap: typeof import('./taphos/collection/flatMap')['flatMap'];
+        };
+        flatMapDeep: {
+          flatMapDeep: typeof import('./taphos/collection/flatMapDeep')['flatMapDeep'];
+        };
+        flatMapDepth: {
+          flatMapDepth: typeof import('./taphos/collection/flatMapDepth')['flatMapDepth'];
+        };
+        includes: {
+          includes: typeof import('./taphos/collection/includes')['includes'];
+        };
+        map: {
+          map: typeof import('./taphos/collection/map')['map'];
+        };
+        pluck: {
+          pluck: typeof import('./taphos/collection/pluck')['pluck'];
+        };
+        reduce: {
+          reduce: typeof import('./taphos/collection/reduce')['reduce'];
+        };
+        reduceRight: {
+          reduceRight: typeof import('./taphos/collection/reduceRight')['reduceRight'];
+        };
+        reject: {
+          reject: typeof import('./taphos/collection/reject')['reject'];
+        };
+        size: {
+          size: typeof import('./taphos/collection/size')['size'];
+        };
+        some: {
+          some: typeof import('./taphos/collection/some')['some'];
+        };
+        sortBy: {
+          sortBy: typeof import('./taphos/collection/sortBy')['sortBy'];
+        };
+        uniq: {
+          uniq: typeof import('./taphos/collection/uniq')['uniq'];
+        };
+        now: {
+          now: typeof import('./taphos/date/now')['now'];
+        };
+        bind: {
+          bind: typeof import('./taphos/function/bind')['bind'];
+        };
+        defer: {
+          defer: typeof import('./taphos/function/defer')['defer'];
+        };
+        delay: {
+          delay: typeof import('./taphos/function/delay')['delay'];
+        };
+        partial: {
+          partial: typeof import('./taphos/function/partial')['partial'];
+        };
+        rest: {
+          rest: typeof import('./taphos/function/rest')['rest'];
+        };
+        spread: {
+          spread: typeof import('./taphos/function/spread')['spread'];
+        };
+        unary: {
+          unary: typeof import('./taphos/function/unary')['unary'];
+        };
+        wrap: {
+          wrap: typeof import('./taphos/function/wrap')['wrap'];
+        };
+        eq: {
+          eq: typeof import('./taphos/lang/eq')['eq'];
+        };
+        gt: {
+          gt: typeof import('./taphos/lang/gt')['gt'];
+        };
+        gte: {
+          gte: typeof import('./taphos/lang/gte')['gte'];
+        };
+        isBuffer: {
+          isBuffer: typeof import('./taphos/lang/isBuffer')['isBuffer'];
+        };
+        isElement: {
+          isElement: typeof import('./taphos/lang/isElement')['isElement'];
+        };
+        isFinite: {
+          isFinite: typeof import('./taphos/lang/isFinite')['isFinite'];
+        };
+        isInteger: {
+          isInteger: typeof import('./taphos/lang/isInteger')['isInteger'];
+        };
+        isNaN: {
+          isNaN: typeof import('./taphos/lang/isNaN')['isNaN'];
+        };
+        isSafeInteger: {
+          isSafeInteger: typeof import('./taphos/lang/isSafeInteger')['isSafeInteger'];
+        };
+        isTypedArray: {
+          isTypedArray: typeof import('./taphos/lang/isTypedArray')['isTypedArray'];
+        };
+        isWeakMap: {
+          isWeakMap: typeof import('./taphos/lang/isWeakMap')['isWeakMap'];
+        };
+        isWeakSet: {
+          isWeakSet: typeof import('./taphos/lang/isWeakSet')['isWeakSet'];
+        };
+        lt: {
+          lt: typeof import('./taphos/lang/lt')['lt'];
+        };
+        lte: {
+          lte: typeof import('./taphos/lang/lte')['lte'];
+        };
+        toFinite: {
+          toFinite: typeof import('./taphos/lang/toFinite')['toFinite'];
+        };
+        toInteger: {
+          toInteger: typeof import('./taphos/lang/toInteger')['toInteger'];
+        };
+        toNumber: {
+          toNumber: typeof import('./taphos/lang/toNumber')['toNumber'];
+        };
+        toSafeInteger: {
+          toSafeInteger: typeof import('./taphos/lang/toSafeInteger')['toSafeInteger'];
+        };
+        add: {
+          add: typeof import('./taphos/math/add')['add'];
+        };
+        ceil: {
+          ceil: typeof import('./taphos/math/ceil')['ceil'];
+        };
+        divide: {
+          divide: typeof import('./taphos/math/divide')['divide'];
+        };
+        floor: {
+          floor: typeof import('./taphos/math/floor')['floor'];
+        };
+        max: {
+          max: typeof import('./taphos/math/max')['max'];
+        };
+        min: {
+          min: typeof import('./taphos/math/min')['min'];
+        };
+        multiply: {
+          multiply: typeof import('./taphos/math/multiply')['multiply'];
+        };
+        round: {
+          round: typeof import('./taphos/math/round')['round'];
+        };
+        subtract: {
+          subtract: typeof import('./taphos/math/subtract')['subtract'];
+        };
+        assign: {
+          assign: typeof import('./taphos/object/assign')['assign'];
+        };
+        at: {
+          at: typeof import('./taphos/object/at')['at'];
+        };
+        create: {
+          create: typeof import('./taphos/object/create')['create'];
+        };
+        extend: {
+          extend: typeof import('./taphos/object/extend')['extend'];
+        };
+        forIn: {
+          forIn: typeof import('./taphos/object/forIn')['forIn'];
+        };
+        forOwn: {
+          forOwn: typeof import('./taphos/object/forOwn')['forOwn'];
+        };
+        hasIn: {
+          hasIn: typeof import('./taphos/object/hasIn')['hasIn'];
+        };
+        invoke: {
+          invoke: typeof import('./taphos/object/invoke')['invoke'];
+        };
+        keys: {
+          keys: typeof import('./taphos/object/keys')['keys'];
+        };
+        toPairs: {
+          toPairs: typeof import('./taphos/object/toPairs')['toPairs'];
+        };
+        transform: {
+          transform: typeof import('./taphos/object/transform')['transform'];
+        };
+        unset: {
+          unset: typeof import('./taphos/object/unset')['unset'];
+        };
+        update: {
+          update: typeof import('./taphos/object/update')['update'];
+        };
+        values: {
+          values: typeof import('./taphos/object/values')['values'];
+        };
+        tap: {
+          tap: typeof import('./taphos/seq/tap')['tap'];
+        };
+        thru: {
+          thru: typeof import('./taphos/seq/thru')['thru'];
+        };
+        endsWith: {
+          endsWith: typeof import('./taphos/string/endsWith')['endsWith'];
+        };
+        pad: {
+          pad: typeof import('./taphos/string/pad')['pad'];
+        };
+        padEnd: {
+          padEnd: typeof import('./taphos/string/padEnd')['padEnd'];
+        };
+        padStart: {
+          padStart: typeof import('./taphos/string/padStart')['padStart'];
+        };
+        parseInteger: {
+          parseInteger: typeof import('./taphos/string/parseInteger')['parseInteger'];
+        };
+        repeat: {
+          repeat: typeof import('./taphos/string/repeat')['repeat'];
+        };
+        replace: {
+          replace: typeof import('./taphos/string/replace')['replace'];
+        };
+        split: {
+          split: typeof import('./taphos/string/split')['split'];
+        };
+        startsWith: {
+          startsWith: typeof import('./taphos/string/startsWith')['startsWith'];
+        };
+        toLower: {
+          toLower: typeof import('./taphos/string/toLower')['toLower'];
+        };
+        toUpper: {
+          toUpper: typeof import('./taphos/string/toUpper')['toUpper'];
+        };
+        trim: {
+          trim: typeof import('./taphos/string/trim')['trim'];
+        };
+        trimEnd: {
+          trimEnd: typeof import('./taphos/string/trimEnd')['trimEnd'];
+        };
+        trimStart: {
+          trimStart: typeof import('./taphos/string/trimStart')['trimStart'];
+        };
+        upperFirst: {
+          upperFirst: typeof import('./taphos/string/upperFirst')['upperFirst'];
+        };
+        attempt: {
+          attempt: typeof import('./taphos/util/attempt')['attempt'];
+        };
+        castArray: {
+          castArray: typeof import('./taphos/util/castArray')['castArray'];
+        };
+        cloneDeep: {
+          cloneDeep: typeof import('./taphos/util/cloneDeep')['cloneDeep'];
+        };
+        constant: {
+          constant: typeof import('./taphos/util/constant')['constant'];
+        };
+        identity: {
+          identity: typeof import('./taphos/util/identity')['identity'];
+        };
+        nthArg: {
+          nthArg: typeof import('./taphos/util/nthArg')['nthArg'];
+        };
+        overEvery: {
+          overEvery: typeof import('./taphos/util/overEvery')['overEvery'];
+        };
+        overSome: {
+          overSome: typeof import('./taphos/util/overSome')['overSome'];
+        };
+        property: {
+          property: typeof import('./taphos/util/property')['property'];
+        };
+        propertyOf: {
+          propertyOf: typeof import('./taphos/util/propertyOf')['propertyOf'];
+        };
+        rangeRight: {
+          rangeRight: typeof import('./taphos/util/rangeRight')['rangeRight'];
+        };
+        stubArray: {
+          stubArray: typeof import('./taphos/util/stubArray')['stubArray'];
+        };
+        stubFalse: {
+          stubFalse: typeof import('./taphos/util/stubFalse')['stubFalse'];
+        };
+        stubObject: {
+          stubObject: typeof import('./taphos/util/stubObject')['stubObject'];
+        };
+        stubString: {
+          stubString: typeof import('./taphos/util/stubString')['stubString'];
+        };
+        stubTrue: {
+          stubTrue: typeof import('./taphos/util/stubTrue')['stubTrue'];
+        };
+        toPath: {
+          toPath: typeof import('./taphos/util/toPath')['toPath'];
+        };
+        predicate: {
+          is_finite: {
+            isFinite: typeof import('./taphos/is/predicate/is-finite')['isFinite'];
+          };
+          is_integer: {
+            isInteger: typeof import('./taphos/is/predicate/is-integer')['isInteger'];
+          };
+          is_nan: {
+            isNaN: typeof import('./taphos/is/predicate/is-nan')['isNaN'];
+          };
+        };
+  };
+  zygos: {
+    either: {
+      ap: typeof import('./zygos/either')['ap'];
+      apFirst: typeof import('./zygos/either')['apFirst'];
+      apS: typeof import('./zygos/either')['apS'];
+      apSecond: typeof import('./zygos/either')['apSecond'];
+      bimap: typeof import('./zygos/either')['bimap'];
+      bind: typeof import('./zygos/either')['bind'];
+      bindTo: typeof import('./zygos/either')['bindTo'];
+      Do: typeof import('./zygos/either')['Do'];
+      elem: typeof import('./zygos/either')['elem'];
+      exists: typeof import('./zygos/either')['exists'];
+      filterOrElse: typeof import('./zygos/either')['filterOrElse'];
+      flatMap: typeof import('./zygos/either')['flatMap'];
+      flatMapNullable: typeof import('./zygos/either')['flatMapNullable'];
+      flatMapOption: typeof import('./zygos/either')['flatMapOption'];
+      flatten: typeof import('./zygos/either')['flatten'];
+      fold: typeof import('./zygos/either')['fold'];
+      fromNullable: typeof import('./zygos/either')['fromNullable'];
+      fromOption: typeof import('./zygos/either')['fromOption'];
+      fromPredicate: typeof import('./zygos/either')['fromPredicate'];
+      getOrElse: typeof import('./zygos/either')['getOrElse'];
+      getOrElseW: typeof import('./zygos/either')['getOrElseW'];
+      isLeft: typeof import('./zygos/either')['isLeft'];
+      isRight: typeof import('./zygos/either')['isRight'];
+      left: typeof import('./zygos/either')['left'];
+      liftNullable: typeof import('./zygos/either')['liftNullable'];
+      liftOption: typeof import('./zygos/either')['liftOption'];
+      map: typeof import('./zygos/either')['map'];
+      mapLeft: typeof import('./zygos/either')['mapLeft'];
+      match: typeof import('./zygos/either')['match'];
+      matchW: typeof import('./zygos/either')['matchW'];
+      orElse: typeof import('./zygos/either')['orElse'];
+      orElseW: typeof import('./zygos/either')['orElseW'];
+      right: typeof import('./zygos/either')['right'];
+      swap: typeof import('./zygos/either')['swap'];
+      tap: typeof import('./zygos/either')['tap'];
+      toUnion: typeof import('./zygos/either')['toUnion'];
+      tryCatch: typeof import('./zygos/either')['tryCatch'];
+      tryCatchK: typeof import('./zygos/either')['tryCatchK'];
+    };
+    option: {
+      alt: typeof import('./zygos/option')['alt'];
+      apFirst: typeof import('./zygos/option')['apFirst'];
+      apSecond: typeof import('./zygos/option')['apSecond'];
+      as: typeof import('./zygos/option')['as'];
+      asUnit: typeof import('./zygos/option')['asUnit'];
+      chain: typeof import('./zygos/option')['chain'];
+      chainNullableK: typeof import('./zygos/option')['chainNullableK'];
+      compact: typeof import('./zygos/option')['compact'];
+      default: typeof import('./zygos/option')['default'];
+      exists: typeof import('./zygos/option')['exists'];
+      filter: typeof import('./zygos/option')['filter'];
+      filterMap: typeof import('./zygos/option')['filterMap'];
+      flap: typeof import('./zygos/option')['flap'];
+      flatMap: typeof import('./zygos/option')['flatMap'];
+      flatten: typeof import('./zygos/option')['flatten'];
+      fold: typeof import('./zygos/option')['fold'];
+      foldW: typeof import('./zygos/option')['foldW'];
+      fromEither: typeof import('./zygos/option')['fromEither'];
+      fromNullable: typeof import('./zygos/option')['fromNullable'];
+      fromNullableK: typeof import('./zygos/option')['fromNullableK'];
+      fromPredicate: typeof import('./zygos/option')['fromPredicate'];
+      getOrElse: typeof import('./zygos/option')['getOrElse'];
+      getOrElseW: typeof import('./zygos/option')['getOrElseW'];
+      isNone: typeof import('./zygos/option')['isNone'];
+      isSome: typeof import('./zygos/option')['isSome'];
+      map: typeof import('./zygos/option')['map'];
+      match: typeof import('./zygos/option')['match'];
+      matchW: typeof import('./zygos/option')['matchW'];
+      none: typeof import('./zygos/option')['none'];
+      of: typeof import('./zygos/option')['of'];
+      option: typeof import('./zygos/option').default;
+      orElse: typeof import('./zygos/option')['orElse'];
+      some: typeof import('./zygos/option')['some'];
+      toEither: typeof import('./zygos/option')['toEither'];
+      toNullable: typeof import('./zygos/option')['toNullable'];
+      toUndefined: typeof import('./zygos/option')['toUndefined'];
+      tryCatch: typeof import('./zygos/option')['tryCatch'];
+      tryCatchK: typeof import('./zygos/option')['tryCatchK'];
+    };
+    orElse: {
+      orElse: typeof import('./zygos/orElse')['orElse'];
+      orElseAsync: typeof import('./zygos/orElse')['orElseAsync'];
+      orElseLazy: typeof import('./zygos/orElse')['orElseLazy'];
+    };
+    safe: {
+      safe: typeof import('./zygos/safe')['safe'];
+    };
+    task_either: {
+      bimap: typeof import('./zygos/task-either')['bimap'];
+      chain: typeof import('./zygos/task-either')['chain'];
+      flatMap: typeof import('./zygos/task-either')['flatMap'];
+      flatten: typeof import('./zygos/task-either')['flatten'];
+      fold: typeof import('./zygos/task-either')['fold'];
+      fromEither: typeof import('./zygos/task-either')['fromEither'];
+      fromNullable: typeof import('./zygos/task-either')['fromNullable'];
+      fromOption: typeof import('./zygos/task-either')['fromOption'];
+      fromPredicate: typeof import('./zygos/task-either')['fromPredicate'];
+      fromTask: typeof import('./zygos/task-either')['fromTask'];
+      getOrElse: typeof import('./zygos/task-either')['getOrElse'];
+      left: typeof import('./zygos/task-either')['left'];
+      map: typeof import('./zygos/task-either')['map'];
+      mapBoth: typeof import('./zygos/task-either')['mapBoth'];
+      mapError: typeof import('./zygos/task-either')['mapError'];
+      mapLeft: typeof import('./zygos/task-either')['mapLeft'];
+      match: typeof import('./zygos/task-either')['match'];
+      of: typeof import('./zygos/task-either')['of'];
+      orElse: typeof import('./zygos/task-either')['orElse'];
+      right: typeof import('./zygos/task-either')['right'];
+      swap: typeof import('./zygos/task-either')['swap'];
+      tryCatch: typeof import('./zygos/task-either')['tryCatch'];
+    };
+    task: {
+      ap: typeof import('./zygos/task')['ap'];
+      flatMap: typeof import('./zygos/task')['flatMap'];
+      map: typeof import('./zygos/task')['map'];
+      of: typeof import('./zygos/task')['of'];
+    };
+        result: {
+          err: typeof import('./zygos/result/result')['err'];
+          Err: typeof import('./zygos/result/result')['Err'];
+          errAsync: typeof import('./zygos/result/result')['errAsync'];
+          fromAsyncThrowable: typeof import('./zygos/result/result')['fromAsyncThrowable'];
+          fromEither: typeof import('./zygos/result/result')['fromEither'];
+          fromOption: typeof import('./zygos/result/result')['fromOption'];
+          fromPromise: typeof import('./zygos/result/result')['fromPromise'];
+          fromSafePromise: typeof import('./zygos/result/result')['fromSafePromise'];
+          ok: typeof import('./zygos/result/result')['ok'];
+          Ok: typeof import('./zygos/result/result')['Ok'];
+          okAsync: typeof import('./zygos/result/result')['okAsync'];
+          ResultAsync: typeof import('./zygos/result/result')['ResultAsync'];
+          safeAsyncTry: typeof import('./zygos/result/result')['safeAsyncTry'];
+          safeTry: typeof import('./zygos/result/result')['safeTry'];
+          toEither: typeof import('./zygos/result/result')['toEither'];
+        };
+        result_async: {
+          errAsync: typeof import('./zygos/result/result-async')['errAsync'];
+          fromAsyncThrowable: typeof import('./zygos/result/result-async')['fromAsyncThrowable'];
+          fromPromise: typeof import('./zygos/result/result-async')['fromPromise'];
+          fromSafePromise: typeof import('./zygos/result/result-async')['fromSafePromise'];
+          okAsync: typeof import('./zygos/result/result-async')['okAsync'];
+          ResultAsync: typeof import('./zygos/result/result-async')['ResultAsync'];
+        };
+  };
+};
+
+export default _autocompletion;
+
+// ============================================
+// 🎯 Direct namespace exports
+// ============================================
+
+/** 
+ * @deprecated ⚠️ For autocompletion only.
+ * Use direct imports from 'arkhe/...' to preserve tree-shaking.
+ * @example
+ * import { chunk } from 'pithos/arkhe/array/chunk';
+ */
+declare const arkhe: typeof _autocompletion.arkhe;
+export { arkhe };
+
+/** 
+ * @deprecated ⚠️ For autocompletion only.
+ * Use direct imports from 'kanon/...' to preserve tree-shaking.
+ * @example
+ * import { parse } from 'pithos/kanon/index';
+ */
+declare const kanon: typeof _autocompletion.kanon;
+export { kanon };
+
+/** 
+ * @deprecated ⚠️ For autocompletion only.
+ * Use direct imports from 'sphalma/...' to preserve tree-shaking.
+ * @example
+ * import { createErrorFactory } from 'pithos/sphalma/error-factory';
+ */
+declare const sphalma: typeof _autocompletion.sphalma;
+export { sphalma };
+
+/** 
+ * @deprecated ⚠️ For autocompletion only.
+ * Use direct imports from 'taphos/...' to preserve tree-shaking.
+ * @example
+ * import { at } from 'pithos/taphos/array/at';
+ */
+declare const taphos: typeof _autocompletion.taphos;
+export { taphos };
+
+/** 
+ * @deprecated ⚠️ For autocompletion only.
+ * Use direct imports from 'zygos/...' to preserve tree-shaking.
+ * @example
+ * import { left } from 'pithos/zygos/either';
+ */
+declare const zygos: typeof _autocompletion.zygos;
+export { zygos };
+