apiculture - v0.2.0

apiculture

Types

Alphabet

</> 
pub type Alphabet =
  alphabet.Alphabet

Checksum

</> 
pub type Checksum =
  checksum.Checksum

Encoding

</> 
pub type Encoding =
  encoding.Encoding

Error

</> 
pub type Error =
  error.Error

Key

</> 
pub type Key =
  key.Key

KeyConfig

</> 
pub type KeyConfig =
  key.KeyConfig

Values

alphabet_characters

</> 
pub fn alphabet_characters(
  alphabet: alphabet.Alphabet,
) -> List(String)

alphabet_size

</> 
pub fn alphabet_size(alphabet: alphabet.Alphabet) -> Int

base32_crockford

</> 
pub fn base32_crockford() -> encoding.Encoding

base32_hex

</> 
pub fn base32_hex() -> encoding.Encoding

base32_rfc

</> 
pub fn base32_rfc() -> encoding.Encoding

base32_rfc_unpadded

</> 
pub fn base32_rfc_unpadded() -> encoding.Encoding

base32_z

</> 
pub fn base32_z() -> encoding.Encoding

base36

</> 
pub fn base36() -> encoding.Encoding

base58

</> 
pub fn base58() -> encoding.Encoding

base62

</> 
pub fn base62() -> encoding.Encoding

base64

</> 
pub fn base64() -> encoding.Encoding

base64_url

</> 
pub fn base64_url() -> encoding.Encoding

checksum_format

</> 
pub fn checksum_format(
  csum: checksum.Checksum,
  bytes: BitArray,
  format_with: fn(BitArray) -> String,
) -> String

checksum_mismatch_error

</> 
pub fn checksum_mismatch_error() -> error.Error

checksum_verify

</> 
pub fn checksum_verify(
  csum: checksum.Checksum,
  bytes: BitArray,
  expected: BitArray,
) -> Bool

crc32

</> 
pub fn crc32() -> checksum.Checksum

default_generate

</> 
pub fn default_generate() -> Result(key.Key, error.Error)

Generate a default format key without a prefix.

This produces a key in the format: <base62-random><checksum>

default_prefixed

</> 
pub fn default_prefixed(
  prefix: String,
) -> Result(key.Key, error.Error)

Generate a default format key with the given prefix.

This produces a key in the format: <prefix>_<base62-random><checksum>

The prefix should be a short semantic identifier (e.g., “sk”, “token”, “key”).

duplicate_characters_error

</> 
pub fn duplicate_characters_error() -> error.Error

empty_alphabet_error

</> 
pub fn empty_alphabet_error() -> error.Error

encoding_decode

</> 
pub fn encoding_decode(
  enc: encoding.Encoding,
  input: String,
) -> Result(BitArray, error.Error)

encoding_encode

</> 
pub fn encoding_encode(
  enc: encoding.Encoding,
  bytes: BitArray,
) -> String

encoding_name

</> 
pub fn encoding_name(enc: encoding.Encoding) -> String

encoding_uses_padding

</> 
pub fn encoding_uses_padding(enc: encoding.Encoding) -> Bool

hex_lower

</> 
pub fn hex_lower() -> encoding.Encoding

hex_upper

</> 
pub fn hex_upper() -> encoding.Encoding

invalid_byte_count_error

</> 
pub fn invalid_byte_count_error() -> error.Error

invalid_encoding_error

</> 
pub fn invalid_encoding_error() -> error.Error

key_bytes

</> 
pub fn key_bytes(k: key.Key) -> BitArray

key_from_bytes

</> 
pub fn key_from_bytes(
  config: key.KeyConfig,
  bytes: BitArray,
) -> Result(key.Key, error.Error)

key_from_ulid

</> 
pub fn key_from_ulid(
  input: String,
) -> Result(key.Key, error.Error)

key_from_ulid_with

</> 
pub fn key_from_ulid_with(
  config: key.KeyConfig,
  input: String,
) -> Result(key.Key, error.Error)

key_from_uuid

</> 
pub fn key_from_uuid(
  input: String,
) -> Result(key.Key, error.Error)

key_from_uuid_with

</> 
pub fn key_from_uuid_with(
  config: key.KeyConfig,
  input: String,
) -> Result(key.Key, error.Error)

key_generate

</> 
pub fn key_generate(
  config: key.KeyConfig,
) -> Result(key.Key, error.Error)

key_new

</> 
pub fn key_new() -> key.KeyConfig

key_value

</> 
pub fn key_value(k: key.Key) -> String

key_with_alphabet

</> 
pub fn key_with_alphabet(
  config: key.KeyConfig,
  alphabet: alphabet.Alphabet,
) -> key.KeyConfig

key_with_checksum

</> 
pub fn key_with_checksum(
  config: key.KeyConfig,
  checksum: checksum.Checksum,
) -> key.KeyConfig

key_with_encoding

</> 
pub fn key_with_encoding(
  config: key.KeyConfig,
  encoding: encoding.Encoding,
) -> key.KeyConfig

key_with_prefix

</> 
pub fn key_with_prefix(
  config: key.KeyConfig,
  prefix: String,
) -> key.KeyConfig

key_with_random_bytes

</> 
pub fn key_with_random_bytes(
  config: key.KeyConfig,
  count: Int,
) -> key.KeyConfig

key_with_random_chars

</> 
pub fn key_with_random_chars(
  config: key.KeyConfig,
  count: Int,
) -> key.KeyConfig

key_with_separator

</> 
pub fn key_with_separator(
  config: key.KeyConfig,
  separator: String,
) -> key.KeyConfig

key_without_checksum

</> 
pub fn key_without_checksum(
  config: key.KeyConfig,
) -> key.KeyConfig

malformed_input_error

</> 
pub fn malformed_input_error() -> error.Error

new_alphabet

</> 
pub fn new_alphabet(
  chars: String,
) -> Result(alphabet.Alphabet, error.Error)

secure_random_unavailable_error

</> 
pub fn secure_random_unavailable_error() -> error.Error

single_character_alphabet_error

</> 
pub fn single_character_alphabet_error() -> error.Error
✨ Search Document