-spec external_binary_to_term(Binary) -> {ok, Term, Rest} | {error, Reason}
                           when
                               Binary :: binary(),
                               Term :: term(),
                               Rest :: bitstring(),
                               Reason :: term().

-spec external_binary_to_vterm(Binary) -> {ok, VTerm, Rest} | {error, Reason}
                            when
                                Binary :: binary(),
                                VTerm :: vterm:t(),
                                Rest :: bitstring(),
                                Reason :: term().

-spec external_binary_to_vterm_lazy(Binary, Limit) -> {ok, VTerm, Rest} | {error, Reason}
                                 when
                                     Binary :: binary(),
                                     Limit :: integer(),
                                     VTerm :: vterm:t(),
                                     Rest :: bitstring(),
                                     Reason :: term().

-spec internal_binary_to_term(Binary) -> {ok, Term, Rest} | {error, Reason}
                           when
                               Binary :: binary(),
                               Term :: term(),
                               Rest :: bitstring(),
                               Reason :: term().

-spec internal_binary_to_vterm(Binary) -> {ok, VTerm, Rest} | {error, Reason}
                            when
                                Binary :: binary(),
                                VTerm :: vterm:t(),
                                Rest :: bitstring(),
                                Reason :: term().

-spec internal_binary_to_vterm_atom(Binary) -> {ok, VTermAtom, Rest} | {error, Reason}
                                 when
                                     Binary :: binary(),
                                     VTermAtom :: vterm:atom_t(),
                                     Rest :: bitstring(),
                                     Reason :: term().

-spec internal_binary_to_vterm_elements(Arity, Binary, PrevVTermElements) ->
                                     {ok, NextVTermElements, Rest} | {error, Reason}
                                     when
                                         Arity :: non_neg_integer(),
                                         Binary :: binary(),
                                         PrevVTermElements :: [vterm:t()],
                                         NextVTermElements :: [vterm:t()],
                                         Rest :: bitstring(),
                                         Reason :: term().

-spec internal_binary_to_vterm_fixed_integer(Binary) -> {ok, VTermFixedInteger, Rest} | {error, Reason}
                                          when
                                              Binary :: binary(),
                                              VTermFixedInteger :: vterm:fixed_integer_t(),
                                              Rest :: bitstring(),
                                              Reason :: term().

-spec internal_binary_to_vterm_lazy(Binary, Limit) -> {ok, VTerm, Rest} | {error, Reason}
                                 when
                                     Binary :: binary(),
                                     Limit :: integer(),
                                     VTerm :: vterm:t(),
                                     Rest :: bitstring(),
                                     Reason :: term().

-spec internal_binary_to_vterm_pairs(Arity, Binary, PrevVTermPairs) ->
                                  {ok, NextVTermPairs, Rest} | {error, Reason}
                                  when
                                      Arity :: non_neg_integer(),
                                      Binary :: binary(),
                                      PrevVTermPairs :: [{VTermKey, VTermValue}],
                                      NextVTermPairs :: [{VTermKey, VTermValue}],
                                      VTermKey :: vterm:t(),
                                      VTermValue :: vterm:t(),
                                      Rest :: bitstring(),
                                      Reason :: term().

-spec internal_binary_to_vterm_pid(Binary) -> {ok, VTermPid, Rest} | {error, Reason}
                                when
                                    Binary :: binary(),
                                    VTermPid :: vterm:pid_t(),
                                    Rest :: bitstring(),
                                    Reason :: term().

-spec internal_binary_to_vterm_small_integer(Binary) -> {ok, VTermSmallInteger, Rest} | {error, Reason}
                                          when
                                              Binary :: binary(),
                                              VTermSmallInteger :: vterm:small_integer_t(),
                                              Rest :: bitstring(),
                                              Reason :: term().

-spec vterm_lazy_limit_dec() -> Limit when Limit :: integer().

-spec vterm_lazy_limit_erase() -> dynamic().

-spec vterm_lazy_limit_get() -> Limit when Limit :: integer().

-spec vterm_lazy_limit_set(undefined) -> ok;
                    (Limit) -> ok when Limit :: integer().