* API overview *


---------------------- Module: [wasi_ephemeral_crypto_symmetric] ----------------------

enum crypto_errno: (tag: u16)
    - `success`: crypto_errno
    - `guest_error`: crypto_errno
    - `not_implemented`: crypto_errno
    - `unsupported_feature`: crypto_errno
    - `prohibited_operation`: crypto_errno
    - `unsupported_encoding`: crypto_errno
    - `unsupported_algorithm`: crypto_errno
    - `unsupported_option`: crypto_errno
    - `invalid_key`: crypto_errno
    - `invalid_length`: crypto_errno
    - `verification_failed`: crypto_errno
    - `rng_error`: crypto_errno
    - `algorithm_failure`: crypto_errno
    - `invalid_signature`: crypto_errno
    - `closed`: crypto_errno
    - `invalid_handle`: crypto_errno
    - `overflow`: crypto_errno
    - `internal_error`: crypto_errno
    - `too_many_handles`: crypto_errno
    - `key_not_supported`: crypto_errno
    - `key_required`: crypto_errno
    - `invalid_tag`: crypto_errno
    - `invalid_operation`: crypto_errno
    - `nonce_required`: crypto_errno
    - `invalid_nonce`: crypto_errno
    - `option_not_set`: crypto_errno
    - `not_found`: crypto_errno
    - `parameters_missing`: crypto_errno
    - `in_progress`: crypto_errno
    - `incompatible_keys`: crypto_errno
    - `expired`: crypto_errno

enum keypair_encoding: (tag: u16)
    - `raw`: keypair_encoding
    - `pkcs8`: keypair_encoding
    - `pem`: keypair_encoding
    - `local`: keypair_encoding

enum publickey_encoding: (tag: u16)
    - `raw`: publickey_encoding
    - `pkcs8`: publickey_encoding
    - `pem`: publickey_encoding
    - `sec`: publickey_encoding
    - `compressed_sec`: publickey_encoding
    - `local`: publickey_encoding

enum secretkey_encoding: (tag: u16)
    - `raw`: secretkey_encoding
    - `pkcs8`: secretkey_encoding
    - `pem`: secretkey_encoding
    - `sec`: secretkey_encoding
    - `compressed_sec`: secretkey_encoding
    - `local`: secretkey_encoding

enum signature_encoding: (tag: u16)
    - `raw`: signature_encoding
    - `der`: signature_encoding

enum algorithm_type: (tag: u16)
    - `signatures`: algorithm_type
    - `symmetric`: algorithm_type
    - `key_exchange`: algorithm_type

alias version = u64

alias size = usize

alias timestamp = u64

alias u64 = u64

alias array_output = handle

alias options = handle

alias secrets_manager = handle

alias keypair = handle

alias signature_state = handle

alias signature = handle

alias publickey = handle

alias secretkey = handle

alias signature_verification_state = handle

alias symmetric_state = handle

alias symmetric_key = handle

alias symmetric_tag = handle

enum opt_options_u: (tag: u8)
    - `some`: opt_options_u
    - `none`: opt_options_u

union opt_options: (tag: u8)
    - `some`: options
    - `none`: (empty)

enum opt_symmetric_key_u: (tag: u8)
    - `some`: opt_symmetric_key_u
    - `none`: opt_symmetric_key_u

union opt_symmetric_key: (tag: u8)
    - `some`: symmetric_key
    - `none`: (empty)

function symmetric_key_generate(): crypto_errno
    - Input:
        - `algorithm`: string
        - `options`: opt_options
    - Output:
        - mut_ptr<symmetric_key>

function symmetric_key_import(): crypto_errno
    - Input:
        - `algorithm`: string
        - `raw`: ptr<u8>
        - `raw_len`: size
    - Output:
        - mut_ptr<symmetric_key>

function symmetric_key_export(): crypto_errno
    - Input:
        - `symmetric_key`: symmetric_key
    - Output:
        - mut_ptr<array_output>

function symmetric_key_close(): crypto_errno
    - Input:
        - `symmetric_key`: symmetric_key
    - No output

function symmetric_key_generate_managed(): crypto_errno
    - Input:
        - `secrets_manager`: secrets_manager
        - `algorithm`: string
        - `options`: opt_options
    - Output:
        - mut_ptr<symmetric_key>

function symmetric_key_store_managed(): crypto_errno
    - Input:
        - `secrets_manager`: secrets_manager
        - `symmetric_key`: symmetric_key
        - `symmetric_key_id`: mut_ptr<u8>
        - `symmetric_key_id_max_len`: size
    - No output

function symmetric_key_replace_managed(): crypto_errno
    - Input:
        - `secrets_manager`: secrets_manager
        - `symmetric_key_old`: symmetric_key
        - `symmetric_key_new`: symmetric_key
    - Output:
        - mut_ptr<version>

function symmetric_key_id(): crypto_errno
    - Input:
        - `symmetric_key`: symmetric_key
        - `symmetric_key_id`: mut_ptr<u8>
        - `symmetric_key_id_max_len`: size
    - Output:
        - mut_ptr<size>
        - mut_ptr<version>

function symmetric_key_from_id(): crypto_errno
    - Input:
        - `secrets_manager`: secrets_manager
        - `symmetric_key_id`: ptr<u8>
        - `symmetric_key_id_len`: size
        - `symmetric_key_version`: version
    - Output:
        - mut_ptr<symmetric_key>

function symmetric_state_open(): crypto_errno
    - Input:
        - `algorithm`: string
        - `key`: opt_symmetric_key
        - `options`: opt_options
    - Output:
        - mut_ptr<symmetric_state>

function symmetric_state_options_get(): crypto_errno
    - Input:
        - `handle`: symmetric_state
        - `name`: string
        - `value`: mut_ptr<u8>
        - `value_max_len`: size
    - Output:
        - mut_ptr<size>

function symmetric_state_options_get_u64(): crypto_errno
    - Input:
        - `handle`: symmetric_state
        - `name`: string
    - Output:
        - mut_ptr<u64>

function symmetric_state_close(): crypto_errno
    - Input:
        - `handle`: symmetric_state
    - No output

function symmetric_state_absorb(): crypto_errno
    - Input:
        - `handle`: symmetric_state
        - `data`: ptr<u8>
        - `data_len`: size
    - No output

function symmetric_state_squeeze(): crypto_errno
    - Input:
        - `handle`: symmetric_state
        - `out`: mut_ptr<u8>
        - `out_len`: size
    - No output

function symmetric_state_squeeze_tag(): crypto_errno
    - Input:
        - `handle`: symmetric_state
    - Output:
        - mut_ptr<symmetric_tag>

function symmetric_state_squeeze_key(): crypto_errno
    - Input:
        - `handle`: symmetric_state
        - `alg_str`: string
    - Output:
        - mut_ptr<symmetric_key>

function symmetric_state_max_tag_len(): crypto_errno
    - Input:
        - `handle`: symmetric_state
    - Output:
        - mut_ptr<size>

function symmetric_state_encrypt(): crypto_errno
    - Input:
        - `handle`: symmetric_state
        - `out`: mut_ptr<u8>
        - `out_len`: size
        - `data`: ptr<u8>
        - `data_len`: size
    - Output:
        - mut_ptr<size>

function symmetric_state_encrypt_detached(): crypto_errno
    - Input:
        - `handle`: symmetric_state
        - `out`: mut_ptr<u8>
        - `out_len`: size
        - `data`: ptr<u8>
        - `data_len`: size
    - Output:
        - mut_ptr<symmetric_tag>

function symmetric_state_decrypt(): crypto_errno
    - Input:
        - `handle`: symmetric_state
        - `out`: mut_ptr<u8>
        - `out_len`: size
        - `data`: ptr<u8>
        - `data_len`: size
    - Output:
        - mut_ptr<size>

function symmetric_state_decrypt_detached(): crypto_errno
    - Input:
        - `handle`: symmetric_state
        - `out`: mut_ptr<u8>
        - `out_len`: size
        - `data`: ptr<u8>
        - `data_len`: size
        - `raw_tag`: ptr<u8>
        - `raw_tag_len`: size
    - Output:
        - mut_ptr<size>

function symmetric_state_ratchet(): crypto_errno
    - Input:
        - `handle`: symmetric_state
    - No output

function symmetric_tag_len(): crypto_errno
    - Input:
        - `symmetric_tag`: symmetric_tag
    - Output:
        - mut_ptr<size>

function symmetric_tag_pull(): crypto_errno
    - Input:
        - `symmetric_tag`: symmetric_tag
        - `buf`: mut_ptr<u8>
        - `buf_len`: size
    - Output:
        - mut_ptr<size>

function symmetric_tag_verify(): crypto_errno
    - Input:
        - `symmetric_tag`: symmetric_tag
        - `expected_raw_tag_ptr`: ptr<u8>
        - `expected_raw_tag_len`: size
    - No output

function symmetric_tag_close(): crypto_errno
    - Input:
        - `symmetric_tag`: symmetric_tag
    - No output