apiculture

-module(apiculture).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/apiculture.gleam").
-export([empty_alphabet_error/0, single_character_alphabet_error/0, duplicate_characters_error/0, secure_random_unavailable_error/0, invalid_byte_count_error/0, invalid_encoding_error/0, malformed_input_error/0, checksum_mismatch_error/0, new_alphabet/1, alphabet_characters/1, alphabet_size/1, key_new/0, key_new_as_string/0, key_new_as_config/0, key_generate/1, key_config_is_ready/1, key_from_bytes/2, bytes_from_uuid/1, bytes_from_ulid/1, key_from_uuid/1, key_from_uuid_with_config/2, key_from_ulid/1, key_from_ulid_with_config/2, key_parse/1, key_default_format/0, key_parse_with_format/2, key_value/1, key_to_string/1, key_bytes/1, key_prefix_value/1, key_separator_value/1, key_has_prefix/1, key_has_checksum/1, key_content_value/1, key_content_bytes/1, key_content_byte_count/1, key_content_char_count/1, key_checksum_name/1, key_checksum_value/1, key_checksum_bytes/1, key_checksum_byte_count/1, key_checksum_char_count/1, key_verify_checksum/1, key_verify_checksum_with_algo/2, key_sections/1, key_with_random_bytes/2, key_with_random_chars/2, key_with_alphabet/2, key_with_encoding/2, key_with_prefix/2, key_with_separator/2, key_with_checksum/2, key_with_checksum_bytes/2, key_disable_prefix/1, key_disable_checksum_name/1, key_disable_checksum/1, key_format_with_prefix/2, key_format_without_prefix/1, key_format_with_separator/2, key_format_with_encoding/2, key_format_with_checksum/2, key_format_without_checksum_name/1, key_format_without_checksum/1, key_format_with_checksum_bytes/2, key_format_with_content_bytes/2, encoding_encode/2, encoding_decode/2, encoding_uses_padding/1, encoding_name/1, hex_lower/0, hex_upper/0, base32_rfc/0, base32_rfc_unpadded/0, base32_hex/0, base32_crockford/0, base32_z/0, base36/0, base58/0, base62/0, base64/0, base64_url/0, checksum_format/3, checksum_verify/3, crc32/0, default_generate/0, default_prefixed/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Apiculture - cryptographically secure API-key generation for Gleam.\n"
    "\n"
    " The top-level module provides the v0.3.0 API for generating, importing,\n"
    " parsing, inspecting, and verifying structured API keys. Start here for\n"
    " ordinary application use; the lower-level modules are available when a\n"
    " more specialized encoding, alphabet, or checksum workflow is needed.\n"
).

-file("src/apiculture.gleam", 63).
?DOC(" Returns the error for an empty custom alphabet.\n").
-spec empty_alphabet_error() -> apiculture@error:error().
empty_alphabet_error() ->
    empty_alphabet.

-file("src/apiculture.gleam", 68).
?DOC(" Returns the error for a one-character custom alphabet.\n").
-spec single_character_alphabet_error() -> apiculture@error:error().
single_character_alphabet_error() ->
    single_character_alphabet.

-file("src/apiculture.gleam", 73).
?DOC(" Returns the error for a custom alphabet containing duplicate characters.\n").
-spec duplicate_characters_error() -> apiculture@error:error().
duplicate_characters_error() ->
    duplicate_characters.

-file("src/apiculture.gleam", 78).
?DOC(" Returns the error raised when secure randomness is unavailable.\n").
-spec secure_random_unavailable_error() -> apiculture@error:error().
secure_random_unavailable_error() ->
    secure_random_unavailable.

-file("src/apiculture.gleam", 83).
?DOC(" Returns the error for an invalid or incomplete byte/character count.\n").
-spec invalid_byte_count_error() -> apiculture@error:error().
invalid_byte_count_error() ->
    invalid_byte_count.

-file("src/apiculture.gleam", 88).
?DOC(" Returns the error for an invalid encoding configuration.\n").
-spec invalid_encoding_error() -> apiculture@error:error().
invalid_encoding_error() ->
    invalid_encoding.

-file("src/apiculture.gleam", 93).
?DOC(" Returns the error for malformed encoded, UUID, ULID, or serialized input.\n").
-spec malformed_input_error() -> apiculture@error:error().
malformed_input_error() ->
    malformed_input.

-file("src/apiculture.gleam", 98).
?DOC(" Returns the error for a checksum that does not match its content.\n").
-spec checksum_mismatch_error() -> apiculture@error:error().
checksum_mismatch_error() ->
    checksum_mismatch.

-file("src/apiculture.gleam", 109).
?DOC(
    " Creates a validated custom alphabet for direct character sampling.\n"
    "\n"
    " The alphabet must contain at least two unique graphemes.\n"
).
-spec new_alphabet(binary()) -> {ok, apiculture@alphabet:alphabet()} |
    {error, apiculture@error:error()}.
new_alphabet(Chars) ->
    apiculture@alphabet:new_alphabet(Chars).

-file("src/apiculture.gleam", 114).
?DOC(" Returns the graphemes in a validated alphabet.\n").
-spec alphabet_characters(apiculture@alphabet:alphabet()) -> list(binary()).
alphabet_characters(Alphabet) ->
    apiculture@alphabet:characters(Alphabet).

-file("src/apiculture.gleam", 119).
?DOC(" Returns the number of graphemes in an alphabet.\n").
-spec alphabet_size(apiculture@alphabet:alphabet()) -> integer().
alphabet_size(Alphabet) ->
    apiculture@alphabet:size(Alphabet).

-file("src/apiculture.gleam", 131).
?DOC(
    " Generates one key using the v0.3.0 default format.\n"
    "\n"
    " The default is `sk_<content>_crc32_<checksum>` with 16 random bytes encoded\n"
    " as Base62 and a four-byte CRC32 checksum.\n"
).
-spec key_new() -> {ok, apiculture@key:key()} |
    {error, apiculture@error:error()}.
key_new() ->
    apiculture@key:new_default().

-file("src/apiculture.gleam", 142).
?DOC(
    " Generates and serializes one key using the v0.3.0 default format.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " let assert Ok(value) = key_new_as_string()\n"
    " ```\n"
).
-spec key_new_as_string() -> {ok, binary()} | {error, apiculture@error:error()}.
key_new_as_string() ->
    apiculture@key:new_as_string().

-file("src/apiculture.gleam", 158).
?DOC(
    " Returns a ready-to-generate configuration containing the default settings.\n"
    "\n"
    " Use the `key_with_*` and `key_disable_*` functions to customize it.\n"
    "\n"
    " ## Examples\n"
    "\n"
    " ```gleam\n"
    " let assert Ok(key) =\n"
    "   key_new_as_config()\n"
    "   |> key_with_prefix(\"partner\")\n"
    "   |> key_generate\n"
    " ```\n"
).
-spec key_new_as_config() -> apiculture@key:key_config().
key_new_as_config() ->
    apiculture@key:new_as_config().

-file("src/apiculture.gleam", 166).
?DOC(
    " Finalizes a random-generation configuration as a `Key`.\n"
    "\n"
    " This is a terminal operation. It generates fresh content according to the\n"
    " selected mode and retains the rendered sections for later inspection.\n"
).
-spec key_generate(apiculture@key:key_config()) -> {ok, apiculture@key:key()} |
    {error, apiculture@error:error()}.
key_generate(Config) ->
    apiculture@key:generate(Config).

-file("src/apiculture.gleam", 171).
?DOC(" Reports whether a configuration contains one valid content-generation mode.\n").
-spec key_config_is_ready(apiculture@key:key_config()) -> boolean().
key_config_is_ready(Config) ->
    apiculture@key:is_ready(Config).

-file("src/apiculture.gleam", 178).
?DOC(
    " Formats existing bytes using a key configuration.\n"
    "\n"
    " This is the terminal step for parse-then-format UUID and ULID workflows.\n"
).
-spec key_from_bytes(apiculture@key:key_config(), bitstring()) -> {ok,
        apiculture@key:key()} |
    {error, apiculture@error:error()}.
key_from_bytes(Config, Bytes) ->
    apiculture@key:from_bytes(Config, Bytes).

-file("src/apiculture.gleam", 186).
?DOC(" Parses a UUID into its canonical 16 bytes.\n").
-spec bytes_from_uuid(binary()) -> {ok, bitstring()} |
    {error, apiculture@error:error()}.
bytes_from_uuid(Input) ->
    apiculture@key:bytes_from_uuid(Input).

-file("src/apiculture.gleam", 191).
?DOC(" Parses a ULID into its canonical 16 bytes.\n").
-spec bytes_from_ulid(binary()) -> {ok, bitstring()} |
    {error, apiculture@error:error()}.
bytes_from_ulid(Input) ->
    apiculture@key:bytes_from_ulid(Input).

-file("src/apiculture.gleam", 199).
?DOC(
    " Imports a UUID using the v0.3.0 default key format.\n"
    "\n"
    " This is a terminal operation. Use `bytes_from_uuid` followed by\n"
    " `key_from_bytes` when the formatting pipeline needs to remain explicit.\n"
).
-spec key_from_uuid(binary()) -> {ok, apiculture@key:key()} |
    {error, apiculture@error:error()}.
key_from_uuid(Input) ->
    apiculture@key:from_uuid(Input).

-file("src/apiculture.gleam", 204).
?DOC(" Imports a UUID and formats it with a supplied configuration.\n").
-spec key_from_uuid_with_config(apiculture@key:key_config(), binary()) -> {ok,
        apiculture@key:key()} |
    {error, apiculture@error:error()}.
key_from_uuid_with_config(Config, Input) ->
    apiculture@key:from_uuid_with_config(Config, Input).

-file("src/apiculture.gleam", 212).
?DOC(" Imports a ULID using the v0.3.0 default key format.\n").
-spec key_from_ulid(binary()) -> {ok, apiculture@key:key()} |
    {error, apiculture@error:error()}.
key_from_ulid(Input) ->
    apiculture@key:from_ulid(Input).

-file("src/apiculture.gleam", 217).
?DOC(" Imports a ULID and formats it with a supplied configuration.\n").
-spec key_from_ulid_with_config(apiculture@key:key_config(), binary()) -> {ok,
        apiculture@key:key()} |
    {error, apiculture@error:error()}.
key_from_ulid_with_config(Config, Input) ->
    apiculture@key:from_ulid_with_config(Config, Input).

-file("src/apiculture.gleam", 228).
?DOC(
    " Parses and verifies a key in the strict default serialized format.\n"
    "\n"
    " A successful result has canonical Base62 content, the expected `sk` prefix,\n"
    " 16 content bytes, and a matching four-byte CRC32 checksum.\n"
).
-spec key_parse(binary()) -> {ok, apiculture@key:key()} |
    {error, apiculture@error:error()}.
key_parse(Input) ->
    apiculture@key:parse(Input).

-file("src/apiculture.gleam", 233).
?DOC(" Returns the parse format corresponding to the v0.3.0 default.\n").
-spec key_default_format() -> apiculture@key:key_format().
key_default_format() ->
    apiculture@key:default_format().

-file("src/apiculture.gleam", 238).
?DOC(" Parses and verifies a key using an explicitly supplied format.\n").
-spec key_parse_with_format(binary(), apiculture@key:key_format()) -> {ok,
        apiculture@key:key()} |
    {error, apiculture@error:error()}.
key_parse_with_format(Input, Format) ->
    apiculture@key:parse_with_format(Input, Format).

-file("src/apiculture.gleam", 248).
?DOC(
    " Returns the serialized value of a finalized key.\n"
    "\n"
    " Prefer `key_to_string` in pipelines; this name remains for compatibility.\n"
).
-spec key_value(apiculture@key:key()) -> binary().
key_value(K) ->
    apiculture@key:value(K).

-file("src/apiculture.gleam", 253).
?DOC(" Returns the serialized value of a finalized key.\n").
-spec key_to_string(apiculture@key:key()) -> binary().
key_to_string(K) ->
    apiculture@key:value(K).

-file("src/apiculture.gleam", 260).
?DOC(
    " Returns the raw content bytes of a finalized key.\n"
    "\n"
    " This is a compatibility alias for `key_content_bytes`.\n"
).
-spec key_bytes(apiculture@key:key()) -> bitstring().
key_bytes(K) ->
    apiculture@key:bytes(K).

-file("src/apiculture.gleam", 265).
?DOC(" Returns the optional serialized prefix.\n").
-spec key_prefix_value(apiculture@key:key()) -> gleam@option:option(binary()).
key_prefix_value(K) ->
    apiculture@key:prefix_value(K).

-file("src/apiculture.gleam", 270).
?DOC(" Returns the optional structural separator.\n").
-spec key_separator_value(apiculture@key:key()) -> gleam@option:option(binary()).
key_separator_value(K) ->
    apiculture@key:separator_value(K).

-file("src/apiculture.gleam", 275).
?DOC(" Reports whether the key has a prefix.\n").
-spec key_has_prefix(apiculture@key:key()) -> boolean().
key_has_prefix(K) ->
    apiculture@key:has_prefix(K).

-file("src/apiculture.gleam", 280).
?DOC(" Reports whether the key has a checksum.\n").
-spec key_has_checksum(apiculture@key:key()) -> boolean().
key_has_checksum(K) ->
    apiculture@key:has_checksum(K).

-file("src/apiculture.gleam", 285).
?DOC(" Returns the encoded content section without prefix or checksum sections.\n").
-spec key_content_value(apiculture@key:key()) -> binary().
key_content_value(K) ->
    apiculture@key:content_value(K).

-file("src/apiculture.gleam", 290).
?DOC(" Returns the raw bytes represented by the content section.\n").
-spec key_content_bytes(apiculture@key:key()) -> bitstring().
key_content_bytes(K) ->
    apiculture@key:content_bytes(K).

-file("src/apiculture.gleam", 295).
?DOC(" Returns the number of raw content bytes.\n").
-spec key_content_byte_count(apiculture@key:key()) -> integer().
key_content_byte_count(K) ->
    apiculture@key:content_byte_count(K).

-file("src/apiculture.gleam", 300).
?DOC(" Returns the number of characters in the encoded content section.\n").
-spec key_content_char_count(apiculture@key:key()) -> integer().
key_content_char_count(K) ->
    apiculture@key:content_char_count(K).

-file("src/apiculture.gleam", 305).
?DOC(" Returns the optional lowercase checksum algorithm name.\n").
-spec key_checksum_name(apiculture@key:key()) -> gleam@option:option(binary()).
key_checksum_name(K) ->
    apiculture@key:checksum_name(K).

-file("src/apiculture.gleam", 310).
?DOC(" Returns the optional encoded checksum section.\n").
-spec key_checksum_value(apiculture@key:key()) -> gleam@option:option(binary()).
key_checksum_value(K) ->
    apiculture@key:checksum_value(K).

-file("src/apiculture.gleam", 315).
?DOC(" Returns the optional raw checksum bytes.\n").
-spec key_checksum_bytes(apiculture@key:key()) -> gleam@option:option(bitstring()).
key_checksum_bytes(K) ->
    apiculture@key:checksum_bytes(K).

-file("src/apiculture.gleam", 320).
?DOC(" Returns the checksum byte count, or `0` when no checksum is present.\n").
-spec key_checksum_byte_count(apiculture@key:key()) -> integer().
key_checksum_byte_count(K) ->
    apiculture@key:checksum_byte_count(K).

-file("src/apiculture.gleam", 325).
?DOC(" Returns the encoded checksum character count, when present.\n").
-spec key_checksum_char_count(apiculture@key:key()) -> gleam@option:option(integer()).
key_checksum_char_count(K) ->
    apiculture@key:checksum_char_count(K).

-file("src/apiculture.gleam", 330).
?DOC(" Verifies a key with the default CRC32 algorithm.\n").
-spec key_verify_checksum(apiculture@key:key()) -> boolean().
key_verify_checksum(K) ->
    apiculture@key:verify_default_checksum(K).

-file("src/apiculture.gleam", 335).
?DOC(" Verifies a key with an explicitly supplied checksum algorithm.\n").
-spec key_verify_checksum_with_algo(
    apiculture@key:key(),
    apiculture@checksum:checksum()
) -> boolean().
key_verify_checksum_with_algo(K, Csum) ->
    apiculture@key:verify_checksum(K, Csum).

-file("src/apiculture.gleam", 340).
?DOC(" Returns all serialized and raw key sections as one value.\n").
-spec key_sections(apiculture@key:key()) -> apiculture@key:key_sections().
key_sections(K) ->
    apiculture@key:sections(K).

-file("src/apiculture.gleam", 346).
?DOC(" Selects secure random byte generation with the given byte count.\n").
-spec key_with_random_bytes(apiculture@key:key_config(), integer()) -> apiculture@key:key_config().
key_with_random_bytes(Config, Count) ->
    apiculture@key:with_random_bytes(Config, Count).

-file("src/apiculture.gleam", 354).
?DOC(
    " Selects direct alphabet sampling with the given character count.\n"
    "\n"
    " Pair this with `key_with_alphabet`; it is distinct from generating random\n"
    " bytes and then encoding them.\n"
).
-spec key_with_random_chars(apiculture@key:key_config(), integer()) -> apiculture@key:key_config().
key_with_random_chars(Config, Count) ->
    apiculture@key:with_random_chars(Config, Count).

-file("src/apiculture.gleam", 359).
?DOC(" Sets the alphabet used by direct character sampling.\n").
-spec key_with_alphabet(
    apiculture@key:key_config(),
    apiculture@alphabet:alphabet()
) -> apiculture@key:key_config().
key_with_alphabet(Config, Alphabet) ->
    apiculture@key:with_alphabet(Config, Alphabet).

-file("src/apiculture.gleam", 364).
?DOC(" Sets the encoding used for content and checksum sections.\n").
-spec key_with_encoding(
    apiculture@key:key_config(),
    apiculture@encoding:encoding()
) -> apiculture@key:key_config().
key_with_encoding(Config, Encoding) ->
    apiculture@key:with_encoding(Config, Encoding).

-file("src/apiculture.gleam", 369).
?DOC(" Sets the serialized key prefix.\n").
-spec key_with_prefix(apiculture@key:key_config(), binary()) -> apiculture@key:key_config().
key_with_prefix(Config, Prefix) ->
    apiculture@key:with_prefix(Config, Prefix).

-file("src/apiculture.gleam", 374).
?DOC(" Sets the separator used at every structural boundary.\n").
-spec key_with_separator(apiculture@key:key_config(), binary()) -> apiculture@key:key_config().
key_with_separator(Config, Separator) ->
    apiculture@key:with_separator(Config, Separator).

-file("src/apiculture.gleam", 379).
?DOC(" Sets the checksum algorithm and serialized algorithm name.\n").
-spec key_with_checksum(
    apiculture@key:key_config(),
    apiculture@checksum:checksum()
) -> apiculture@key:key_config().
key_with_checksum(Config, Checksum) ->
    apiculture@key:with_checksum(Config, Checksum).

-file("src/apiculture.gleam", 384).
?DOC(" Sets the number of checksum bytes retained in the key.\n").
-spec key_with_checksum_bytes(apiculture@key:key_config(), integer()) -> apiculture@key:key_config().
key_with_checksum_bytes(Config, Count) ->
    apiculture@key:with_checksum_bytes(Config, Count).

-file("src/apiculture.gleam", 389).
?DOC(" Removes the prefix from a key configuration.\n").
-spec key_disable_prefix(apiculture@key:key_config()) -> apiculture@key:key_config().
key_disable_prefix(Config) ->
    apiculture@key:disable_prefix(Config).

-file("src/apiculture.gleam", 394).
?DOC(" Removes the checksum name while retaining the checksum.\n").
-spec key_disable_checksum_name(apiculture@key:key_config()) -> apiculture@key:key_config().
key_disable_checksum_name(Config) ->
    apiculture@key:disable_checksum_name(Config).

-file("src/apiculture.gleam", 399).
?DOC(" Removes both the checksum and its serialized name.\n").
-spec key_disable_checksum(apiculture@key:key_config()) -> apiculture@key:key_config().
key_disable_checksum(Config) ->
    apiculture@key:without_checksum(Config).

-file("src/apiculture.gleam", 404).
?DOC(" Changes the expected prefix in a parser format.\n").
-spec key_format_with_prefix(apiculture@key:key_format(), binary()) -> apiculture@key:key_format().
key_format_with_prefix(Format, Prefix) ->
    apiculture@key:format_with_prefix(Format, Prefix).

-file("src/apiculture.gleam", 409).
?DOC(" Removes the expected prefix from a parser format.\n").
-spec key_format_without_prefix(apiculture@key:key_format()) -> apiculture@key:key_format().
key_format_without_prefix(Format) ->
    apiculture@key:format_without_prefix(Format).

-file("src/apiculture.gleam", 414).
?DOC(" Changes the expected separator in a parser format.\n").
-spec key_format_with_separator(apiculture@key:key_format(), binary()) -> apiculture@key:key_format().
key_format_with_separator(Format, Separator) ->
    apiculture@key:format_with_separator(Format, Separator).

-file("src/apiculture.gleam", 422).
?DOC(" Changes the expected encoding in a parser format.\n").
-spec key_format_with_encoding(
    apiculture@key:key_format(),
    apiculture@encoding:encoding()
) -> apiculture@key:key_format().
key_format_with_encoding(Format, Encoding) ->
    apiculture@key:format_with_encoding(Format, Encoding).

-file("src/apiculture.gleam", 430).
?DOC(" Changes the expected checksum algorithm in a parser format.\n").
-spec key_format_with_checksum(
    apiculture@key:key_format(),
    apiculture@checksum:checksum()
) -> apiculture@key:key_format().
key_format_with_checksum(Format, Checksum) ->
    apiculture@key:format_with_checksum(Format, Checksum).

-file("src/apiculture.gleam", 438).
?DOC(" Removes the expected checksum name from a parser format.\n").
-spec key_format_without_checksum_name(apiculture@key:key_format()) -> apiculture@key:key_format().
key_format_without_checksum_name(Format) ->
    apiculture@key:format_without_checksum_name(Format).

-file("src/apiculture.gleam", 443).
?DOC(" Removes the expected checksum from a parser format.\n").
-spec key_format_without_checksum(apiculture@key:key_format()) -> apiculture@key:key_format().
key_format_without_checksum(Format) ->
    apiculture@key:format_without_checksum(Format).

-file("src/apiculture.gleam", 448).
?DOC(" Changes the expected checksum byte count in a parser format.\n").
-spec key_format_with_checksum_bytes(apiculture@key:key_format(), integer()) -> apiculture@key:key_format().
key_format_with_checksum_bytes(Format, Count) ->
    apiculture@key:format_with_checksum_bytes(Format, Count).

-file("src/apiculture.gleam", 456).
?DOC(" Changes the expected content byte count in a parser format.\n").
-spec key_format_with_content_bytes(apiculture@key:key_format(), integer()) -> apiculture@key:key_format().
key_format_with_content_bytes(Format, Count) ->
    apiculture@key:format_with_content_bytes(Format, Count).

-file("src/apiculture.gleam", 468).
?DOC(" Encodes bytes with an apiculture encoding.\n").
-spec encoding_encode(apiculture@encoding:encoding(), bitstring()) -> binary().
encoding_encode(Enc, Bytes) ->
    apiculture@encoding:encode(Enc, Bytes).

-file("src/apiculture.gleam", 473).
?DOC(" Decodes a string with an apiculture encoding.\n").
-spec encoding_decode(apiculture@encoding:encoding(), binary()) -> {ok,
        bitstring()} |
    {error, apiculture@error:error()}.
encoding_decode(Enc, Input) ->
    apiculture@encoding:decode(Enc, Input).

-file("src/apiculture.gleam", 481).
?DOC(" Reports whether an encoding uses padding.\n").
-spec encoding_uses_padding(apiculture@encoding:encoding()) -> boolean().
encoding_uses_padding(Enc) ->
    apiculture@encoding:uses_padding(Enc).

-file("src/apiculture.gleam", 486).
?DOC(" Returns the multibase name of an encoding.\n").
-spec encoding_name(apiculture@encoding:encoding()) -> binary().
encoding_name(Enc) ->
    apiculture@encoding:name(Enc).

-file("src/apiculture.gleam", 492).
?DOC(" Returns lowercase hexadecimal encoding.\n").
-spec hex_lower() -> apiculture@encoding:encoding().
hex_lower() ->
    apiculture@encoding:hex_lower().

-file("src/apiculture.gleam", 497).
?DOC(" Returns uppercase hexadecimal encoding.\n").
-spec hex_upper() -> apiculture@encoding:encoding().
hex_upper() ->
    apiculture@encoding:hex_upper().

-file("src/apiculture.gleam", 503).
?DOC(" Returns padded RFC 4648 Base32 encoding.\n").
-spec base32_rfc() -> apiculture@encoding:encoding().
base32_rfc() ->
    apiculture@encoding:base32_rfc().

-file("src/apiculture.gleam", 508).
?DOC(" Returns unpadded RFC 4648 Base32 encoding.\n").
-spec base32_rfc_unpadded() -> apiculture@encoding:encoding().
base32_rfc_unpadded() ->
    apiculture@encoding:base32_rfc_unpadded().

-file("src/apiculture.gleam", 513).
?DOC(" Returns Base32hex encoding.\n").
-spec base32_hex() -> apiculture@encoding:encoding().
base32_hex() ->
    apiculture@encoding:base32_hex().

-file("src/apiculture.gleam", 518).
?DOC(" Returns Crockford Base32 encoding.\n").
-spec base32_crockford() -> apiculture@encoding:encoding().
base32_crockford() ->
    apiculture@encoding:base32_crockford().

-file("src/apiculture.gleam", 523).
?DOC(" Returns z-base-32 encoding.\n").
-spec base32_z() -> apiculture@encoding:encoding().
base32_z() ->
    apiculture@encoding:base32_z().

-file("src/apiculture.gleam", 529).
?DOC(" Returns lowercase Base36 encoding.\n").
-spec base36() -> apiculture@encoding:encoding().
base36() ->
    apiculture@encoding:base36().

-file("src/apiculture.gleam", 535).
?DOC(" Returns Bitcoin-style Base58 encoding.\n").
-spec base58() -> apiculture@encoding:encoding().
base58() ->
    apiculture@encoding:base58().

-file("src/apiculture.gleam", 541).
?DOC(" Returns Base62 encoding.\n").
-spec base62() -> apiculture@encoding:encoding().
base62() ->
    apiculture@encoding:base62().

-file("src/apiculture.gleam", 547).
?DOC(" Returns standard padded Base64 encoding.\n").
-spec base64() -> apiculture@encoding:encoding().
base64() ->
    apiculture@encoding:base64().

-file("src/apiculture.gleam", 552).
?DOC(" Returns URL-safe padded Base64 encoding.\n").
-spec base64_url() -> apiculture@encoding:encoding().
base64_url() ->
    apiculture@encoding:base64_url().

-file("src/apiculture.gleam", 561).
?DOC(" Formats a checksum using a caller-provided byte encoding function.\n").
-spec checksum_format(
    apiculture@checksum:checksum(),
    bitstring(),
    fun((bitstring()) -> binary())
) -> binary().
checksum_format(Csum, Bytes, Format_with) ->
    apiculture@checksum:format(Csum, Bytes, Format_with).

-file("src/apiculture.gleam", 570).
?DOC(" Verifies raw bytes against an expected checksum.\n").
-spec checksum_verify(apiculture@checksum:checksum(), bitstring(), bitstring()) -> boolean().
checksum_verify(Csum, Bytes, Expected) ->
    apiculture@checksum:verify(Csum, Bytes, Expected).

-file("src/apiculture.gleam", 579).
?DOC(" Returns the CRC32 checksum algorithm used by the default key format.\n").
-spec crc32() -> apiculture@checksum:checksum().
crc32() ->
    apiculture@checksum:crc32_checksum().

-file("src/apiculture.gleam", 591).
?DOC(
    " Compatibility alias for generating a v0.3.0 default key.\n"
    "\n"
    " Prefer `key_new()` in new code. This function returns the same structured\n"
    " `sk_<content>_crc32_<checksum>` format.\n"
).
-spec default_generate() -> {ok, apiculture@key:key()} |
    {error, apiculture@error:error()}.
default_generate() ->
    apiculture@default_key:generate().

-file("src/apiculture.gleam", 600).
?DOC(
    " Generates a v0.3.0 structured key with a custom prefix.\n"
    "\n"
    " The format is `<prefix>_<content>_crc32_<checksum>`.\n"
    "\n"
    " The prefix should be a short semantic identifier (e.g., \"sk\", \"token\", \"key\").\n"
).
-spec default_prefixed(binary()) -> {ok, apiculture@key:key()} |
    {error, apiculture@error:error()}.
default_prefixed(Prefix) ->
    apiculture@default_key:prefixed(Prefix).