diff --git a/Cargo.lock b/Cargo.lock index 97cbc3929..c7e0b01fd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,6 +2,21 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "addr2line" +version = "0.24.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1" +dependencies = [ + "gimli", +] + +[[package]] +name = "adler2" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627" + [[package]] name = "aead" version = "0.5.2" @@ -65,7 +80,7 @@ version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c" dependencies = [ - "windows-sys", + "windows-sys 0.59.0", ] [[package]] @@ -76,7 +91,7 @@ checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e" dependencies = [ "anstyle", "once_cell", - "windows-sys", + "windows-sys 0.59.0", ] [[package]] @@ -109,12 +124,123 @@ dependencies = [ "zeroize", ] +[[package]] +name = "askama" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b79091df18a97caea757e28cd2d5fda49c6cd4bd01ddffd7ff01ace0c0ad2c28" +dependencies = [ + "askama_derive 0.12.5", + "askama_escape", +] + +[[package]] +name = "askama" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d4744ed2eef2645831b441d8f5459689ade2ab27c854488fbab1fbe94fce1a7" +dependencies = [ + "askama_derive 0.13.1", + "itoa", + "percent-encoding", + "serde", + "serde_json", +] + +[[package]] +name = "askama_derive" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19fe8d6cb13c4714962c072ea496f3392015f0989b1a2847bb4b2d9effd71d83" +dependencies = [ + "askama_parser 0.2.1", + "basic-toml", + "mime", + "mime_guess", + "proc-macro2", + "quote", + "serde", + "syn 2.0.101", +] + +[[package]] +name = "askama_derive" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d661e0f57be36a5c14c48f78d09011e67e0cb618f269cca9f2fd8d15b68c46ac" +dependencies = [ + "askama_parser 0.13.0", + "basic-toml", + "memchr", + "proc-macro2", + "quote", + "rustc-hash", + "serde", + "serde_derive", + "syn 2.0.101", +] + +[[package]] +name = "askama_escape" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "619743e34b5ba4e9703bba34deac3427c72507c7159f5fd030aea8cac0cfe341" + +[[package]] +name = "askama_parser" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "acb1161c6b64d1c3d83108213c2a2533a342ac225aabd0bda218278c2ddb00c0" +dependencies = [ + "nom", +] + +[[package]] +name = "askama_parser" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf315ce6524c857bb129ff794935cf6d42c82a6cff60526fe2a63593de4d0d4f" +dependencies = [ + "memchr", + "serde", + "serde_derive", + "winnow", +] + +[[package]] +name = "async-compat" +version = "0.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bab94bde396a3f7b4962e396fdad640e241ed797d4d8d77fc8c237d14c58fc0" +dependencies = [ + "futures-core", + "futures-io", + "once_cell", + "pin-project-lite", + "tokio", +] + [[package]] name = "autocfg" version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" +[[package]] +name = "backtrace" +version = "0.3.75" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002" +dependencies = [ + "addr2line", + "cfg-if", + "libc", + "miniz_oxide", + "object", + "rustc-demangle", + "windows-targets", +] + [[package]] name = "base64" version = "0.11.0" @@ -148,6 +274,15 @@ dependencies = [ "serde", ] +[[package]] +name = "bincode" +version = "1.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad" +dependencies = [ + "serde", +] + [[package]] name = "bitflags" version = "2.9.0" @@ -258,6 +393,20 @@ dependencies = [ "thiserror 1.0.69", ] +[[package]] +name = "cargo_metadata" +version = "0.19.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba" +dependencies = [ + "camino", + "cargo-platform", + "semver", + "serde", + "serde_json", + "thiserror 2.0.12", +] + [[package]] name = "cbc" version = "0.1.2" @@ -269,9 +418,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.2.20" +version = "1.2.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "04da6a0d40b948dfc4fa8f5bbf402b0fc1a64a28dbf7d12ffd683550f2c1b63a" +checksum = "32db95edf998450acc7881c932f94cd9b05c87b4b2599e8bab064753da4acfd1" dependencies = [ "shlex", ] @@ -319,9 +468,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.37" +version = "4.5.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eccb054f56cbd38340b380d4a8e69ef1f02f1af43db2f0cc817a4774d80ae071" +checksum = "ed93b9805f8ba930df42c2590f05453d5ec36cbb85d018868a5b24d31f6ac000" dependencies = [ "clap_builder", "clap_derive", @@ -329,9 +478,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.37" +version = "4.5.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "efd9466fac8543255d3b1fcad4762c5e116ffe808c8a3043d4263cd4fd4862a2" +checksum = "379026ff283facf611b0ea629334361c4211d1b12ee01024eec1591133b04120" dependencies = [ "anstream", "anstyle", @@ -345,10 +494,10 @@ version = "4.5.32" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09176aae279615badda0765c0c0b3f6ed53f4709118af73cf4655d85d1530cd7" dependencies = [ - "heck", + "heck 0.5.0", "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -419,7 +568,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -460,7 +609,7 @@ dependencies = [ "dyn-clone", "ed25519-dalek", "getrandom 0.2.16", - "getrandom 0.3.2", + "getrandom 0.3.3", "hmac", "js-sys", "num_enum", @@ -524,8 +673,17 @@ name = "devolutions-crypto-uniffi" version = "0.9.3" dependencies = [ "devolutions-crypto", - "uniffi", + "uniffi 0.29.2", + "uniffi-builder-macro", +] + +[[package]] +name = "devolutions-crypto-uniffi-dart" +version = "0.9.3" +dependencies = [ + "devolutions-crypto", "uniffi-builder-macro", + "uniffi-dart", ] [[package]] @@ -576,6 +734,22 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" +[[package]] +name = "errno" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e" +dependencies = [ + "libc", + "windows-sys 0.59.0", +] + +[[package]] +name = "fastrand" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" + [[package]] name = "fiat-crypto" version = "0.2.9" @@ -597,6 +771,117 @@ dependencies = [ "autocfg", ] +[[package]] +name = "futures" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" + +[[package]] +name = "futures-executor" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6" + +[[package]] +name = "futures-macro" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.101", +] + +[[package]] +name = "futures-sink" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7" + +[[package]] +name = "futures-task" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" + +[[package]] +name = "futures-util" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "genco" +version = "0.17.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a35958104272e516c2a5f66a9d82fba4784d2b585fc1e2358b8f96e15d342995" +dependencies = [ + "genco-macros", + "relative-path", + "smallvec", +] + +[[package]] +name = "genco-macros" +version = "0.17.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43eaff6bbc0b3a878361aced5ec6a2818ee7c541c5b33b5880dfa9a86c23e9e7" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.101", +] + [[package]] name = "generic-array" version = "0.14.7" @@ -622,9 +907,9 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0" +checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4" dependencies = [ "cfg-if", "js-sys", @@ -634,12 +919,29 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "gimli" +version = "0.31.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f" + [[package]] name = "glob" version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2" +[[package]] +name = "goblin" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d6b4de4a8eb6c46a8c77e1d3be942cb9a8bf073c22374578e5ba4b08ed0ff68" +dependencies = [ + "log", + "plain", + "scroll 0.11.0", +] + [[package]] name = "goblin" version = "0.8.2" @@ -648,20 +950,26 @@ checksum = "1b363a30c165f666402fe6a3024d3bec7ebc898f96a4a23bd1c99f8dbf3f4f47" dependencies = [ "log", "plain", - "scroll", + "scroll 0.12.0", ] [[package]] name = "hashbrown" -version = "0.15.2" +version = "0.15.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" +checksum = "84b26c544d002229e640969970a2e74021aadf6e2f96372b9c58eff97de08eb3" dependencies = [ "allocator-api2", "equivalent", "foldhash", ] +[[package]] +name = "heck" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" + [[package]] name = "heck" version = "0.5.0" @@ -725,6 +1033,12 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "lazy_static" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" + [[package]] name = "libc" version = "0.2.172" @@ -741,6 +1055,22 @@ dependencies = [ "cc", ] +[[package]] +name = "linux-raw-sys" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12" + +[[package]] +name = "lock_api" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17" +dependencies = [ + "autocfg", + "scopeguard", +] + [[package]] name = "log" version = "0.4.27" @@ -794,6 +1124,26 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" +[[package]] +name = "miniz_oxide" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3be647b768db090acb35d5ec5db2b0e1f1de11133ca123b9eacf5137868f892a" +dependencies = [ + "adler2", +] + +[[package]] +name = "mio" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2886843bf800fba2e3377cff24abf6379b4c4d5c6681eaf9ea5b0d15090450bd" +dependencies = [ + "libc", + "wasi 0.11.0+wasi-snapshot-preview1", + "windows-sys 0.52.0", +] + [[package]] name = "nom" version = "7.1.3" @@ -822,7 +1172,16 @@ dependencies = [ "proc-macro-crate", "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", +] + +[[package]] +name = "object" +version = "0.36.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87" +dependencies = [ + "memchr", ] [[package]] @@ -831,12 +1190,41 @@ version = "1.21.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" +[[package]] +name = "oneshot" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ce411919553d3f9fa53a0880544cda985a112117a0444d5ff1e870a893d6ea" + [[package]] name = "opaque-debug" version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" +[[package]] +name = "parking_lot" +version = "0.12.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" +dependencies = [ + "lock_api", + "parking_lot_core", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "smallvec", + "windows-targets", +] + [[package]] name = "paste" version = "1.0.15" @@ -853,6 +1241,24 @@ dependencies = [ "hmac", ] +[[package]] +name = "percent-encoding" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" + +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + [[package]] name = "pkcs8" version = "0.10.2" @@ -961,7 +1367,7 @@ dependencies = [ "proc-macro2", "pyo3-macros-backend", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -970,11 +1376,11 @@ version = "0.24.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "822ece1c7e1012745607d5cf0bcb2874769f0f7cb34c4cde03b9358eb9ef911a" dependencies = [ - "heck", + "heck 0.5.0", "proc-macro2", "pyo3-build-config", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -1057,59 +1463,41 @@ version = "0.9.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38" dependencies = [ - "getrandom 0.3.2", + "getrandom 0.3.3", ] [[package]] -name = "rinja" -version = "0.3.5" +name = "redox_syscall" +version = "0.5.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3dc4940d00595430b3d7d5a01f6222b5e5b51395d1120bdb28d854bb8abb17a5" +checksum = "928fca9cf2aa042393a8325b9ead81d2f0df4cb12e1e24cef072922ccd99c5af" dependencies = [ - "itoa", - "rinja_derive", + "bitflags", ] [[package]] -name = "rinja_derive" -version = "0.3.5" +name = "relative-path" +version = "1.9.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08d9ed0146aef6e2825f1b1515f074510549efba38d71f4554eec32eb36ba18b" -dependencies = [ - "basic-toml", - "memchr", - "mime", - "mime_guess", - "proc-macro2", - "quote", - "rinja_parser", - "rustc-hash", - "serde", - "syn 2.0.100", -] - -[[package]] -name = "rinja_parser" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93f9a866e2e00a7a1fb27e46e9e324a6f7c0e7edc4543cae1d38f4e4a100c610" -dependencies = [ - "memchr", - "nom", - "serde", -] - -[[package]] -name = "rust-argon2" -version = "2.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d9848531d60c9cbbcf9d166c885316c24bc0e2a9d3eba0956bb6cbbd79bc6e8" +checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2" + +[[package]] +name = "rust-argon2" +version = "2.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d9848531d60c9cbbcf9d166c885316c24bc0e2a9d3eba0956bb6cbbd79bc6e8" dependencies = [ "base64 0.21.7", "blake2b_simd", "constant_time_eq", ] +[[package]] +name = "rustc-demangle" +version = "0.1.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f" + [[package]] name = "rustc-hash" version = "2.1.1" @@ -1125,6 +1513,19 @@ dependencies = [ "semver", ] +[[package]] +name = "rustix" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.59.0", +] + [[package]] name = "rustversion" version = "1.0.20" @@ -1155,13 +1556,39 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "scroll" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04c565b551bafbef4157586fa379538366e4385d42082f255bfd96e4fe8519da" +dependencies = [ + "scroll_derive 0.11.1", +] + [[package]] name = "scroll" version = "0.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6ab8598aa408498679922eff7fa985c25d58a90771bd6be794434c5277eab1a6" dependencies = [ - "scroll_derive", + "scroll_derive 0.12.1", +] + +[[package]] +name = "scroll_derive" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1db149f81d46d2deba7cd3c50772474707729550221e69588478ebf9ada425ae" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.101", ] [[package]] @@ -1172,7 +1599,7 @@ checksum = "1783eabc414609e28a5ba76aee5ddd52199f7107a0b24c2e9746a1ecc34a683d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -1223,7 +1650,7 @@ checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00" dependencies = [ "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -1240,9 +1667,9 @@ dependencies = [ [[package]] name = "sha2" -version = "0.10.8" +version = "0.10.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" dependencies = [ "cfg-if", "cpufeatures", @@ -1255,6 +1682,15 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" +[[package]] +name = "signal-hook-registry" +version = "1.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9203b8055f63a2a00e2f593bb0510367fe707d7ff1e5c872de2f537b339e5410" +dependencies = [ + "libc", +] + [[package]] name = "signature" version = "2.2.0" @@ -1270,12 +1706,37 @@ version = "0.3.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d" +[[package]] +name = "slab" +version = "0.4.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" +dependencies = [ + "autocfg", +] + +[[package]] +name = "smallvec" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9" + [[package]] name = "smawk" version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c" +[[package]] +name = "socket2" +version = "0.5.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4f5fd57c80058a56cf5c777ab8a126398ece8e442983605d280a44ce79d0edef" +dependencies = [ + "libc", + "windows-sys 0.52.0", +] + [[package]] name = "spki" version = "0.7.3" @@ -1292,6 +1753,12 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" +[[package]] +name = "stringcase" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04028eeb851ed08af6aba5caa29f2d59a13ed168cee4d6bd753aeefcf1d636b0" + [[package]] name = "strsim" version = "0.11.1" @@ -1313,11 +1780,11 @@ version = "0.27.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8" dependencies = [ - "heck", + "heck 0.5.0", "proc-macro2", "quote", "rustversion", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -1339,9 +1806,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.100" +version = "2.0.101" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0" +checksum = "8ce2b7fc941b3a24138a0a7cf8e858bfc6a992e7978a068a5c760deb0ed43caf" dependencies = [ "proc-macro2", "quote", @@ -1354,6 +1821,19 @@ version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a" +[[package]] +name = "tempfile" +version = "3.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8a64e3985349f2441a1a9ef0b853f869006c3855f2cda6862a94d26ebb9d6a1" +dependencies = [ + "fastrand", + "getrandom 0.3.3", + "once_cell", + "rustix", + "windows-sys 0.59.0", +] + [[package]] name = "textwrap" version = "0.16.2" @@ -1389,7 +1869,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" dependencies = [ "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -1400,7 +1880,36 @@ checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d" dependencies = [ "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", +] + +[[package]] +name = "tokio" +version = "1.45.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2513ca694ef9ede0fb23fe71a4ee4107cb102b9dc1930f6d0fd77aae068ae165" +dependencies = [ + "backtrace", + "bytes", + "libc", + "mio", + "parking_lot", + "pin-project-lite", + "signal-hook-registry", + "socket2", + "tokio-macros", + "windows-sys 0.52.0", +] + +[[package]] +name = "tokio-macros" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.101", ] [[package]] @@ -1414,15 +1923,15 @@ dependencies = [ [[package]] name = "toml_datetime" -version = "0.6.8" +version = "0.6.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41" +checksum = "3da5db5a963e24bc68be8b17b6fa82814bb22ee8660f192bb182771d498f09a3" [[package]] name = "toml_edit" -version = "0.22.24" +version = "0.22.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "17b4795ff5edd201c7cd6dca065ae59972ce77d1b80fa0a84d94950ece7d1474" +checksum = "310068873db2c5b3e7659d2cc35d21855dbafa50d1ce336397c666e3cb08137e" dependencies = [ "indexmap", "toml_datetime", @@ -1446,7 +1955,7 @@ checksum = "60d8d828da2a3d759d3519cdf29a5bac49c77d039ad36d0782edadbf9cd5415b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -1469,25 +1978,51 @@ checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512" [[package]] name = "uniffi" -version = "0.29.1" +version = "0.24.3" +source = "git+https://github.com/NiallBunting/uniffi-rs-dart.git#f59dab4cd9962c09b31969cc3c5f4f8b436369db" +dependencies = [ + "anyhow", + "camino", + "clap", + "uniffi_bindgen 0.24.3", + "uniffi_core 0.24.3", + "uniffi_macros 0.24.3", +] + +[[package]] +name = "uniffi" +version = "0.27.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb3a4c447c50fcda7bc5604a8588b7e1f37ffbfd8838a1516a290398efa7c6f0" +dependencies = [ + "anyhow", + "uniffi_build 0.27.3", + "uniffi_core 0.27.3", + "uniffi_macros 0.27.3", +] + +[[package]] +name = "uniffi" +version = "0.29.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe34585ac0275accf6c284d0080cc2840f3898c551cda869ec291b5a4218712c" +checksum = "4dcd1d240101ba3b9d7532ae86d9cb64d9a7ff63e13a2b7b9e94a32a601d8233" dependencies = [ "anyhow", "camino", - "cargo_metadata", + "cargo_metadata 0.19.2", "clap", - "uniffi_bindgen", - "uniffi_build", - "uniffi_core", - "uniffi_macros", + "uniffi_bindgen 0.29.2", + "uniffi_build 0.29.2", + "uniffi_core 0.29.2", + "uniffi_macros 0.29.2", + "uniffi_pipeline", ] [[package]] name = "uniffi-bindgen" version = "0.1.0" dependencies = [ - "uniffi", + "uniffi 0.29.2", ] [[package]] @@ -1495,48 +2030,197 @@ name = "uniffi-builder-macro" version = "0.1.0" dependencies = [ "quote", - "syn 2.0.100", + "syn 2.0.101", +] + +[[package]] +name = "uniffi-dart" +version = "0.1.0" +source = "git+https://github.com/acterglobal/uniffi-dart.git#eb507c3b126c33a9b3fb1b5f6d3b45f852962f15" +dependencies = [ + "anyhow", + "camino", + "genco", + "heck 0.5.0", + "lazy_static", + "paste", + "proc-macro2", + "serde", + "stringcase", + "toml", + "uniffi 0.27.3", + "uniffi_bindgen 0.27.3", + "uniffi_build 0.27.3", + "uniffi_dart_macro", +] + +[[package]] +name = "uniffi-dart-bindgen" +version = "0.1.0" +dependencies = [ + "uniffi 0.24.3", ] [[package]] name = "uniffi_bindgen" -version = "0.29.1" +version = "0.24.3" +source = "git+https://github.com/NiallBunting/uniffi-rs-dart.git#f59dab4cd9962c09b31969cc3c5f4f8b436369db" +dependencies = [ + "anyhow", + "askama 0.12.1", + "camino", + "cargo_metadata 0.15.4", + "clap", + "fs-err", + "glob", + "goblin 0.6.1", + "heck 0.4.1", + "once_cell", + "paste", + "serde", + "toml", + "uniffi_meta 0.24.3", + "uniffi_testing 0.24.3", + "uniffi_udl 0.24.3", +] + +[[package]] +name = "uniffi_bindgen" +version = "0.27.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a792af1424cc8b3c43b44c1a6cb7935ed1fbe5584a74f70e8bab9799740266d" +checksum = "0be2bc6bafd82c979b0faca77c7b26630d54017de9f5bd5a686ec6ef038ad5d9" dependencies = [ "anyhow", + "askama 0.12.1", "camino", - "cargo_metadata", + "cargo_metadata 0.15.4", "fs-err", "glob", - "goblin", - "heck", + "goblin 0.8.2", + "heck 0.4.1", "once_cell", "paste", - "rinja", "serde", "textwrap", "toml", - "uniffi_meta", - "uniffi_udl", + "uniffi_meta 0.27.3", + "uniffi_testing 0.27.3", + "uniffi_udl 0.27.3", +] + +[[package]] +name = "uniffi_bindgen" +version = "0.29.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d0525f06d749ea80d8049dc0bb038bb87941e3d909eefa76b6f0a5589b59ac5" +dependencies = [ + "anyhow", + "askama 0.13.1", + "camino", + "cargo_metadata 0.19.2", + "fs-err", + "glob", + "goblin 0.8.2", + "heck 0.5.0", + "indexmap", + "once_cell", + "serde", + "tempfile", + "textwrap", + "toml", + "uniffi_internal_macros", + "uniffi_meta 0.29.2", + "uniffi_pipeline", + "uniffi_udl 0.29.2", ] [[package]] name = "uniffi_build" -version = "0.29.1" +version = "0.24.3" +source = "git+https://github.com/NiallBunting/uniffi-rs-dart.git#f59dab4cd9962c09b31969cc3c5f4f8b436369db" +dependencies = [ + "anyhow", + "camino", + "uniffi_bindgen 0.24.3", +] + +[[package]] +name = "uniffi_build" +version = "0.27.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c59b65d59685ff3a10569287c6419f76487b4052ac52d5a0df38b2253d7f440" +dependencies = [ + "anyhow", + "camino", + "uniffi_bindgen 0.27.3", +] + +[[package]] +name = "uniffi_build" +version = "0.29.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aed2f0204e942bb9c11c9f11a323b4abf70cf11b2e5957d60b3f2728430f6c6f" +dependencies = [ + "anyhow", + "camino", + "uniffi_bindgen 0.29.2", +] + +[[package]] +name = "uniffi_checksum_derive" +version = "0.24.3" +source = "git+https://github.com/NiallBunting/uniffi-rs-dart.git#f59dab4cd9962c09b31969cc3c5f4f8b436369db" +dependencies = [ + "quote", + "syn 2.0.101", +] + +[[package]] +name = "uniffi_checksum_derive" +version = "0.27.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00c4138211f2ae951018fcce6a978e1fcd1a47c3fd0bc0d5472a520520060db1" +checksum = "d5c400339a9d1d17be34257d0b407e91d64af335e5b4fa49f4bf28467fc8d635" +dependencies = [ + "quote", + "syn 2.0.101", +] + +[[package]] +name = "uniffi_core" +version = "0.24.3" +source = "git+https://github.com/NiallBunting/uniffi-rs-dart.git#f59dab4cd9962c09b31969cc3c5f4f8b436369db" dependencies = [ "anyhow", + "bytes", "camino", - "uniffi_bindgen", + "log", + "once_cell", + "oneshot", + "paste", + "static_assertions", ] [[package]] name = "uniffi_core" -version = "0.29.1" +version = "0.27.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c18baace68a52666d33d12d73ca335ecf27a302202cefb53b1f974512bb72417" +checksum = "a02e67ac9634b10da9e4aa63a29a7920b8f1395eafef1ea659b2dd76dda96906" +dependencies = [ + "anyhow", + "async-compat", + "bytes", + "camino", + "log", + "once_cell", + "paste", + "static_assertions", +] + +[[package]] +name = "uniffi_core" +version = "0.29.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3fa8eb4d825b4ed095cb13483cba6927c3002b9eb603cef9b7688758cc3772e" dependencies = [ "anyhow", "bytes", @@ -1544,54 +2228,193 @@ dependencies = [ "static_assertions", ] +[[package]] +name = "uniffi_dart_macro" +version = "0.1.0" +source = "git+https://github.com/acterglobal/uniffi-dart.git#eb507c3b126c33a9b3fb1b5f6d3b45f852962f15" +dependencies = [ + "futures", + "proc-macro2", + "quote", + "stringcase", + "syn 1.0.109", + "tokio", + "uniffi 0.27.3", +] + [[package]] name = "uniffi_internal_macros" -version = "0.29.1" +version = "0.29.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9902d4ed16c65e6c0222241024dd0bfeed07ea3deb7c470eb175e5f5ef406cd" +checksum = "83b547d69d699e52f2129fde4b57ae0d00b5216e59ed5b56097c95c86ba06095" dependencies = [ + "anyhow", + "indexmap", + "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] name = "uniffi_macros" -version = "0.29.1" +version = "0.24.3" +source = "git+https://github.com/NiallBunting/uniffi-rs-dart.git#f59dab4cd9962c09b31969cc3c5f4f8b436369db" +dependencies = [ + "bincode", + "camino", + "fs-err", + "once_cell", + "proc-macro2", + "quote", + "serde", + "syn 2.0.101", + "toml", + "uniffi_build 0.24.3", + "uniffi_meta 0.24.3", +] + +[[package]] +name = "uniffi_macros" +version = "0.27.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d82c82ef945c51082d8763635334b994e63e77650f09d0fae6d28dd08b1de83" +checksum = "b6f08d5592c669b80a8af5066027098bebec4b4af17a9b8b299bac5f518ab89e" dependencies = [ + "bincode", "camino", "fs-err", "once_cell", "proc-macro2", "quote", "serde", - "syn 2.0.100", + "syn 2.0.101", "toml", - "uniffi_meta", + "uniffi_meta 0.27.3", +] + +[[package]] +name = "uniffi_macros" +version = "0.29.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00f1de72edc8cb9201c7d650e3678840d143e4499004571aac49e6cb1b17da43" +dependencies = [ + "camino", + "fs-err", + "once_cell", + "proc-macro2", + "quote", + "serde", + "syn 2.0.101", + "toml", + "uniffi_meta 0.29.2", +] + +[[package]] +name = "uniffi_meta" +version = "0.24.3" +source = "git+https://github.com/NiallBunting/uniffi-rs-dart.git#f59dab4cd9962c09b31969cc3c5f4f8b436369db" +dependencies = [ + "anyhow", + "bytes", + "siphasher", + "uniffi_checksum_derive 0.24.3", ] [[package]] name = "uniffi_meta" -version = "0.29.1" +version = "0.27.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d6027b971c2aa86350dd180aee9819729c7b99bacd381534511ff29d2c09cea" +checksum = "583bab49f2bdf5681f9732f8b67a7e555ad920dbb5427be21450217bf1818189" +dependencies = [ + "anyhow", + "bytes", + "siphasher", + "uniffi_checksum_derive 0.27.3", +] + +[[package]] +name = "uniffi_meta" +version = "0.29.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3acc9204632f6a555b2cba7c8852c5523bc1aa5f3eff605c64af5054ea28b72e" dependencies = [ "anyhow", "siphasher", "uniffi_internal_macros", + "uniffi_pipeline", +] + +[[package]] +name = "uniffi_pipeline" +version = "0.29.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "54b5336a9a925b358183837d31541d12590b7fcec373256d3770de02dff24c69" +dependencies = [ + "anyhow", + "heck 0.5.0", + "indexmap", + "tempfile", + "uniffi_internal_macros", +] + +[[package]] +name = "uniffi_testing" +version = "0.24.3" +source = "git+https://github.com/NiallBunting/uniffi-rs-dart.git#f59dab4cd9962c09b31969cc3c5f4f8b436369db" +dependencies = [ + "anyhow", + "camino", + "cargo_metadata 0.15.4", + "fs-err", + "once_cell", +] + +[[package]] +name = "uniffi_testing" +version = "0.27.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13963044ca9bde9b709d2eee68bc11dafc7acea144ae0fdc0cf29ed4add44481" +dependencies = [ + "anyhow", + "camino", + "cargo_metadata 0.15.4", + "fs-err", + "once_cell", +] + +[[package]] +name = "uniffi_udl" +version = "0.24.3" +source = "git+https://github.com/NiallBunting/uniffi-rs-dart.git#f59dab4cd9962c09b31969cc3c5f4f8b436369db" +dependencies = [ + "anyhow", + "uniffi_meta 0.24.3", + "uniffi_testing 0.24.3", + "weedle2 4.0.0", ] [[package]] name = "uniffi_udl" -version = "0.29.1" +version = "0.27.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "52300b7a4ab02dc159a038a13d5bfe27aefbad300d91b0b501b3dda094c1e0a2" +checksum = "b92f984bb0d9a06778f256aec963e1e9a80714014f7a90fb0e01008821fe5a97" dependencies = [ "anyhow", "textwrap", - "uniffi_meta", - "weedle2", + "uniffi_meta 0.27.3", + "uniffi_testing 0.27.3", + "weedle2 5.0.0", +] + +[[package]] +name = "uniffi_udl" +version = "0.29.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f95e73373d85f04736bc51997d3e6855721144ec4384cae9ca8513c80615e129" +dependencies = [ + "anyhow", + "textwrap", + "uniffi_meta 0.29.2", + "weedle2 5.0.0", ] [[package]] @@ -1669,7 +2492,7 @@ dependencies = [ "log", "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", "wasm-bindgen-shared", ] @@ -1704,7 +2527,7 @@ checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de" dependencies = [ "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -1739,7 +2562,7 @@ checksum = "17d5042cc5fa009658f9a7333ef24291b1291a25b6382dd68862a7f3b969f69b" dependencies = [ "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -1752,6 +2575,14 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "weedle2" +version = "4.0.0" +source = "git+https://github.com/NiallBunting/uniffi-rs-dart.git#f59dab4cd9962c09b31969cc3c5f4f8b436369db" +dependencies = [ + "nom", +] + [[package]] name = "weedle2" version = "5.0.0" @@ -1767,7 +2598,16 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" dependencies = [ - "windows-sys", + "windows-sys 0.59.0", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets", ] [[package]] @@ -1845,9 +2685,9 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" [[package]] name = "winnow" -version = "0.7.7" +version = "0.7.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6cb8234a863ea0e8cd7284fcdd4f145233eb00fee02bbdd9861aec44e6477bc5" +checksum = "c06928c8748d81b05c9be96aad92e1b6ff01833332f281e8cfca3be4b35fc9ec" dependencies = [ "memchr", ] @@ -1875,22 +2715,22 @@ dependencies = [ [[package]] name = "zerocopy" -version = "0.8.24" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2586fea28e186957ef732a5f8b3be2da217d65c5969d4b1e17f973ebbe876879" +checksum = "a1702d9583232ddb9174e01bb7c15a2ab8fb1bc6f227aa1233858c351a3ba0cb" dependencies = [ "zerocopy-derive", ] [[package]] name = "zerocopy-derive" -version = "0.8.24" +version = "0.8.25" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a996a8f63c5c4448cd959ac1bab0aaa3306ccfd060472f85943ee0750f0169be" +checksum = "28a6e20d751156648aa063f3800b706ee209a32c0b4d9f24be3d980b01be55ef" dependencies = [ "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", ] [[package]] @@ -1910,5 +2750,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2", "quote", - "syn 2.0.100", + "syn 2.0.101", ] diff --git a/Cargo.toml b/Cargo.toml index a86015be8..f1e5a477c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,8 +6,10 @@ members = [ "fuzz", "python", "uniffi/uniffi-bindgen", + "uniffi/uniffi-dart-bindgen", + "uniffi/devolutions-crypto-uniffi-dart", "uniffi/devolutions-crypto-uniffi", - "uniffi/devolutions-crypto-uniffi/uniffi-builder-macro", + "uniffi/uniffi-builder-macro", ] [workspace.dependencies] @@ -59,7 +61,7 @@ x25519-dalek = { version = "2", features = [ "static_secrets" ] } # Version is pinned because newer version requires lifetime annotations # that isn't compatible with the header trait arbitrary = { version = "0.4.7", features = ["derive"], optional = true } -blake3 = { version = "1.6", features = ["zeroize"] } +blake3 = { version = "1.8", features = ["zeroize"] } paste = "1.0.15" dyn-clone = "1.0" diff --git a/uniffi/devolutions-crypto-uniffi-dart/Cargo.toml b/uniffi/devolutions-crypto-uniffi-dart/Cargo.toml new file mode 100644 index 000000000..f7c542750 --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "devolutions-crypto-uniffi-dart" +edition = "2021" +version.workspace = true + +[lib] +crate-type = ["cdylib", "staticlib"] + +[dependencies] +devolutions-crypto = { path = "../../" } +uniffi-builder-macro = { path = "../uniffi-builder-macro" } +uniffi-dart = { git = "https://github.com/acterglobal/uniffi-dart.git" } + +[build-dependencies] +uniffi-dart = { git = "https://github.com/acterglobal/uniffi-dart.git", features = ["build"] } diff --git a/uniffi/devolutions-crypto-uniffi-dart/build.rs b/uniffi/devolutions-crypto-uniffi-dart/build.rs new file mode 100644 index 000000000..e799e4d37 --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/build.rs @@ -0,0 +1,3 @@ +fn main() { + uniffi_dart::generate_scaffolding("./src/devolutions_crypto.udl".into()).unwrap(); +} diff --git a/uniffi/devolutions-crypto-uniffi-dart/src/argon2parameters.rs b/uniffi/devolutions-crypto-uniffi-dart/src/argon2parameters.rs new file mode 100644 index 000000000..bb47d9e52 --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/src/argon2parameters.rs @@ -0,0 +1,42 @@ +use crate::Result; + +use devolutions_crypto::{Argon2Variant, Argon2Version}; + +use uniffi_builder_macro::UniffiBuilder; + +#[UniffiBuilder(Argon2Parameters, devolutions_crypto::argon2parameters_defaults)] +pub struct Argon2ParametersBuilder { + length: u32, + lanes: u32, + memory: u32, + iterations: u32, + variant: Argon2Variant, + version: Argon2Version, + dc_version: u32, + + #[builder_default = Default::default()] + associated_data: Vec, + + #[builder_default = Default::default()] + secret_key: Vec, + + #[builder_default = devolutions_crypto::argon2parameters_defaults::salt().unwrap()] + salt: Vec, +} + +pub struct Argon2Parameters(pub devolutions_crypto::Argon2Parameters); + +impl Argon2Parameters { + pub fn new_from_bytes(data: &[u8]) -> Result { + let data = data.try_into()?; + Ok(Self(data)) + } + + pub fn get_bytes(&self) -> Vec { + (&self.0).into() + } + + fn get_inner_builder() -> devolutions_crypto::Argon2ParametersBuilder { + devolutions_crypto::Argon2Parameters::builder() + } +} diff --git a/uniffi/devolutions-crypto-uniffi-dart/src/ciphertext.rs b/uniffi/devolutions-crypto-uniffi-dart/src/ciphertext.rs new file mode 100644 index 000000000..fbdb96bb6 --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/src/ciphertext.rs @@ -0,0 +1,59 @@ +use crate::CiphertextVersion; +use crate::Result; + +pub fn encrypt(data: &[u8], key: &[u8], version: CiphertextVersion) -> Result> { + Ok(devolutions_crypto::ciphertext::encrypt(data, key, version)?.into()) +} + +pub fn encrypt_with_aad( + data: &[u8], + key: &[u8], + aad: &[u8], + version: CiphertextVersion, +) -> Result> { + Ok(devolutions_crypto::ciphertext::encrypt_with_aad(data, key, aad, version)?.into()) +} + +#[uniffi::export] +pub fn decrypt(data: Vec, key: Vec) -> Result> { + let data = devolutions_crypto::ciphertext::Ciphertext::try_from(data.as_slice())?; + data.decrypt(key.as_slice()) +} + +#[uniffi::export] +fn decrypt_with_aad(data: Vec, key: Vec, aad: Vec) -> Result> { + let data = devolutions_crypto::ciphertext::Ciphertext::try_from(data.as_slice())?; + data.decrypt_with_aad(key.as_slice(), aad.as_slice()) +} + +pub fn encrypt_asymmetric(data: &[u8], key: &[u8], version: CiphertextVersion) -> Result> { + let key = key.try_into()?; + Ok(devolutions_crypto::ciphertext::encrypt_asymmetric(data, &key, version)?.into()) +} + +pub fn encrypt_asymmetric_with_aad( + data: &[u8], + key: &[u8], + aad: &[u8], + version: CiphertextVersion, +) -> Result> { + let key = key.try_into()?; + Ok( + devolutions_crypto::ciphertext::encrypt_asymmetric_with_aad(data, &key, aad, version)? + .into(), + ) +} + +#[uniffi::export] +pub fn decrypt_asymmetric(data: Vec, key: Vec) -> Result> { + let key = key.as_slice().try_into()?; + let data = devolutions_crypto::ciphertext::Ciphertext::try_from(data.as_slice())?; + data.decrypt_asymmetric(&key) +} + +#[uniffi::export] +fn decrypt_asymmetric_with_aad(data: Vec, key: Vec, aad: Vec) -> Result> { + let key = key.as_slice().try_into()?; + let data = devolutions_crypto::ciphertext::Ciphertext::try_from(data.as_slice())?; + data.decrypt_asymmetric_with_aad(&key, aad.as_slice()) +} diff --git a/uniffi/devolutions-crypto-uniffi-dart/src/devolutions_crypto.udl b/uniffi/devolutions-crypto-uniffi-dart/src/devolutions_crypto.udl new file mode 100644 index 000000000..5a9018cc2 --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/src/devolutions_crypto.udl @@ -0,0 +1,151 @@ +enum DataType { + "None", + "Key", + "Ciphertext", + "PasswordHash", + "Share", + "SigningKey", + "Signature", + "OnlineCiphertext", +}; + +enum CiphertextVersion { + "Latest", + "V1", + "V2", +}; + +enum PasswordHashVersion { + "Latest", + "V1", +}; + +enum KeyVersion { + "Latest", + "V1", +}; + +enum SigningKeyVersion { + "Latest", + "V1", +}; + +enum SecretSharingVersion { + "Latest", + "V1", +}; + +enum SignatureVersion { + "Latest", + "V1", +}; + +enum Argon2Version { + "Version10", + "Version13", +}; + +enum Argon2Variant { + "Argon2d", + "Argon2i", + "Argon2id", +}; + +[Error] +enum DevolutionsCryptoError { + "InvalidLength", + "InvalidKeyLength", + "InvalidOutputLength", + "InvalidSignature", + "InvalidMac", + "InvalidDataType", + "UnknownType", + "UnknownSubtype", + "UnknownVersion", + "InvalidData", + "NullPointer", + "CryptoError", + "RandomError", + "IoError", + "NotEnoughShares", + "InconsistentVersion", + "InvalidChunkLength", + "PoisonedMutex", +}; + +interface Argon2ParametersBuilder { + constructor(); + [Self=ByArc] + Argon2ParametersBuilder length(u32 value); + [Self=ByArc] + Argon2ParametersBuilder lanes(u32 value); + [Self=ByArc] + Argon2ParametersBuilder memory(u32 value); + [Self=ByArc] + Argon2ParametersBuilder iterations(u32 value); + [Self=ByArc] + Argon2ParametersBuilder variant(Argon2Variant value); + [Self=ByArc] + Argon2ParametersBuilder version(Argon2Version value); + [Self=ByArc] + Argon2ParametersBuilder dc_version(u32 value); + [Self=ByArc] + Argon2ParametersBuilder associated_data(bytes value); + [Self=ByArc] + Argon2ParametersBuilder secret_key(bytes value); + [Self=ByArc] + Argon2ParametersBuilder salt(bytes value); + [Self=ByArc] + Argon2Parameters build(); +}; + +interface Argon2Parameters { + [Name=new_from_bytes, Throws=DevolutionsCryptoError] + constructor([ByRef] bytes data); + bytes get_bytes(); +}; + +dictionary KeyPair { + bytes public_key; + bytes private_key; +}; + +interface SigningKeyPair { + [Name=new_from_bytes, Throws=DevolutionsCryptoError] + constructor([ByRef] bytes data); + bytes get_public_key(); + bytes get_private_key(); +}; + +namespace devolutions_crypto { + // Ciphertext + [Throws=DevolutionsCryptoError] + bytes encrypt([ByRef] bytes data, [ByRef] bytes key, CiphertextVersion version); + + [Throws=DevolutionsCryptoError] + bytes encrypt_with_aad([ByRef] bytes data, [ByRef] bytes key, [ByRef] bytes aad, CiphertextVersion version); + + [Throws=DevolutionsCryptoError] + bytes encrypt_asymmetric([ByRef] bytes data, [ByRef] bytes key, CiphertextVersion version); + + [Throws=DevolutionsCryptoError] + bytes encrypt_asymmetric_with_aad([ByRef] bytes data, [ByRef] bytes key, [ByRef] bytes aad, CiphertextVersion version); + + // Keys + KeyPair generate_keypair(KeyVersion version); + + // Password Hash + [Throws=DevolutionsCryptoError] + bytes hash_password([ByRef] bytes password, u32 iterations, PasswordHashVersion version); + + // Secret Sharing + [Throws=DevolutionsCryptoError] + sequence generate_shared_key(u8 n_shares, u8 threshold, u32 length, SecretSharingVersion version); + + // Signature + [Throws=DevolutionsCryptoError] + bytes sign([ByRef] bytes data, [ByRef] bytes keypair, SignatureVersion version); + + // Signing Key + SigningKeyPair generate_signing_keypair(SigningKeyVersion version); +}; \ No newline at end of file diff --git a/uniffi/devolutions-crypto-uniffi-dart/src/key.rs b/uniffi/devolutions-crypto-uniffi-dart/src/key.rs new file mode 100644 index 000000000..5d83d4ba8 --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/src/key.rs @@ -0,0 +1,28 @@ +use crate::KeyVersion; +use crate::Result; + +pub struct KeyPair { + pub private_key: Vec, + pub public_key: Vec, +} + +impl From for KeyPair { + fn from(value: devolutions_crypto::key::KeyPair) -> Self { + Self { + private_key: value.private_key.into(), + public_key: value.public_key.into(), + } + } +} + +pub fn generate_keypair(version: KeyVersion) -> KeyPair { + devolutions_crypto::key::generate_keypair(version).into() +} + +#[uniffi::export] +pub fn mix_key_exchange(private_key: Vec, public_key: Vec) -> Result> { + let private_key = private_key.as_slice().try_into()?; + let public_key = public_key.as_slice().try_into()?; + + devolutions_crypto::key::mix_key_exchange(&private_key, &public_key) +} diff --git a/uniffi/devolutions-crypto-uniffi-dart/src/lib.rs b/uniffi/devolutions-crypto-uniffi-dart/src/lib.rs new file mode 100644 index 000000000..df351c3ac --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/src/lib.rs @@ -0,0 +1,32 @@ +mod argon2parameters; +mod ciphertext; +mod key; +mod password_hash; +mod secret_sharing; +mod signature; +mod signing_key; +mod utils; + +pub use argon2parameters::*; +pub use ciphertext::*; +pub use key::*; +pub use password_hash::*; +pub use secret_sharing::*; +pub use signature::*; +pub use signing_key::*; +pub use utils::*; + +pub use devolutions_crypto::Argon2Variant; +pub use devolutions_crypto::Argon2Version; +pub use devolutions_crypto::CiphertextVersion; +pub use devolutions_crypto::DataType; +pub use devolutions_crypto::Error as DevolutionsCryptoError; +pub use devolutions_crypto::KeyVersion; +pub use devolutions_crypto::PasswordHashVersion; +pub use devolutions_crypto::SecretSharingVersion; +pub use devolutions_crypto::SignatureVersion; +pub use devolutions_crypto::SigningKeyVersion; + +pub use devolutions_crypto::Result; + +uniffi_dart::include_scaffolding!("devolutions_crypto"); \ No newline at end of file diff --git a/uniffi/devolutions-crypto-uniffi-dart/src/password_hash.rs b/uniffi/devolutions-crypto-uniffi-dart/src/password_hash.rs new file mode 100644 index 000000000..9df7db7e6 --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/src/password_hash.rs @@ -0,0 +1,16 @@ +use crate::PasswordHashVersion; +use crate::Result; + +pub fn hash_password( + password: &[u8], + iterations: u32, + version: PasswordHashVersion, +) -> Result> { + Ok(devolutions_crypto::password_hash::hash_password(password, iterations, version)?.into()) +} + +#[uniffi::export] +pub fn verify_password(password: Vec, hash: Vec) -> Result { + let hash: devolutions_crypto::password_hash::PasswordHash = hash.as_slice().try_into()?; + Ok(hash.verify_password(password.as_slice())) +} diff --git a/uniffi/devolutions-crypto-uniffi-dart/src/secret_sharing.rs b/uniffi/devolutions-crypto-uniffi-dart/src/secret_sharing.rs new file mode 100644 index 000000000..3d88fae3b --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/src/secret_sharing.rs @@ -0,0 +1,26 @@ +use crate::Result; +use crate::SecretSharingVersion; + +pub fn generate_shared_key( + n_shares: u8, + threshold: u8, + length: u32, + version: SecretSharingVersion, +) -> Result>> { + Ok(devolutions_crypto::secret_sharing::generate_shared_key( + n_shares, + threshold, + length as usize, + version, + )? + .into_iter() + .map(|s| s.into()) + .collect()) +} + +#[uniffi::export] +pub fn join_shares(shares: Vec>) -> Result> { + let shares: Result> = shares.iter().map(|s| s.as_slice().try_into()).collect(); + + devolutions_crypto::secret_sharing::join_shares(&shares?) +} diff --git a/uniffi/devolutions-crypto-uniffi-dart/src/signature.rs b/uniffi/devolutions-crypto-uniffi-dart/src/signature.rs new file mode 100644 index 000000000..d52e2ef1b --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/src/signature.rs @@ -0,0 +1,16 @@ +use crate::Result; +use crate::SignatureVersion; + +pub fn sign(data: &[u8], keypair: &[u8], version: SignatureVersion) -> Result> { + let keypair = keypair.try_into()?; + + Ok(devolutions_crypto::signature::sign(data, &keypair, version).into()) +} + +#[uniffi::export] +pub fn verify_signature(data: Vec, public_key: Vec, signature: Vec) -> Result { + let signature: devolutions_crypto::signature::Signature = signature.as_slice().try_into()?; + let public_key = public_key.as_slice().try_into()?; + + Ok(signature.verify(data.as_slice(), &public_key)) +} diff --git a/uniffi/devolutions-crypto-uniffi-dart/src/signing_key.rs b/uniffi/devolutions-crypto-uniffi-dart/src/signing_key.rs new file mode 100644 index 000000000..05a698ec8 --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/src/signing_key.rs @@ -0,0 +1,41 @@ +use std::sync::Arc; + +use crate::DevolutionsCryptoError; +use crate::Result; +use crate::SigningKeyVersion; + +pub struct SigningKeyPair(devolutions_crypto::signing_key::SigningKeyPair); + +impl SigningKeyPair { + pub fn new_from_bytes(data: &[u8]) -> Result { + data.try_into() + } +} + +impl From for SigningKeyPair { + fn from(value: devolutions_crypto::signing_key::SigningKeyPair) -> Self { + Self(value) + } +} + +impl TryFrom<&[u8]> for SigningKeyPair { + type Error = DevolutionsCryptoError; + + fn try_from(value: &[u8]) -> Result { + Ok(Self(value.try_into()?)) + } +} + +impl SigningKeyPair { + pub fn get_public_key(&self) -> Vec { + self.0.get_public_key().into() + } + + pub fn get_private_key(&self) -> Vec { + self.0.clone().into() + } +} + +pub fn generate_signing_keypair(version: SigningKeyVersion) -> Arc { + Arc::new(devolutions_crypto::signing_key::generate_signing_keypair(version).into()) +} diff --git a/uniffi/devolutions-crypto-uniffi-dart/src/utils.rs b/uniffi/devolutions-crypto-uniffi-dart/src/utils.rs new file mode 100644 index 000000000..dc6665663 --- /dev/null +++ b/uniffi/devolutions-crypto-uniffi-dart/src/utils.rs @@ -0,0 +1,53 @@ +use std::sync::Arc; + +use crate::{Argon2Parameters, DataType, Result}; + +#[uniffi::export] +pub fn generate_key(length: u32) -> Result> { + devolutions_crypto::utils::generate_key(length as usize) +} + +#[uniffi::export] +pub fn derive_key_pbkdf2( + key: Vec, + salt: Option>, + iterations: u32, + length: u32, +) -> Vec { + devolutions_crypto::utils::derive_key_pbkdf2( + key.as_slice(), + &salt.unwrap_or_default(), + iterations, + length as usize, + ) +} + +#[uniffi::export] +pub fn derive_key_argon2(key: Vec, parameters: &Arc) -> Result> { + devolutions_crypto::utils::derive_key_argon2(key.as_slice(), ¶meters.0) +} + +#[uniffi::export] +pub fn validate_header(data: Vec, data_type: DataType) -> bool { + devolutions_crypto::utils::validate_header(data.as_slice(), data_type) +} + +#[uniffi::export] +pub fn base64_encode(data: Vec) -> String { + devolutions_crypto::utils::base64_encode(data.as_slice()) +} + +#[uniffi::export] +pub fn base64_decode(data: &String) -> Result> { + devolutions_crypto::utils::base64_decode(data) +} + +#[uniffi::export] +pub fn base64_encode_url(data: Vec) -> String { + devolutions_crypto::utils::base64_encode_url(data.as_slice()) +} + +#[uniffi::export] +pub fn base64_decode_url(data: &String) -> Result> { + devolutions_crypto::utils::base64_decode_url(data) +} diff --git a/uniffi/devolutions-crypto-uniffi/Cargo.toml b/uniffi/devolutions-crypto-uniffi/Cargo.toml index ab404c42e..8ba7dc5a3 100644 --- a/uniffi/devolutions-crypto-uniffi/Cargo.toml +++ b/uniffi/devolutions-crypto-uniffi/Cargo.toml @@ -8,7 +8,7 @@ crate-type = ["cdylib", "staticlib"] [dependencies] devolutions-crypto = { path = "../../" } -uniffi-builder-macro = { path = "./uniffi-builder-macro" } +uniffi-builder-macro = { path = "../uniffi-builder-macro" } uniffi = { workspace = true } [build-dependencies] diff --git a/uniffi/devolutions-crypto-uniffi/uniffi-builder-macro/Cargo.toml b/uniffi/uniffi-builder-macro/Cargo.toml similarity index 100% rename from uniffi/devolutions-crypto-uniffi/uniffi-builder-macro/Cargo.toml rename to uniffi/uniffi-builder-macro/Cargo.toml diff --git a/uniffi/devolutions-crypto-uniffi/uniffi-builder-macro/src/lib.rs b/uniffi/uniffi-builder-macro/src/lib.rs similarity index 100% rename from uniffi/devolutions-crypto-uniffi/uniffi-builder-macro/src/lib.rs rename to uniffi/uniffi-builder-macro/src/lib.rs diff --git a/uniffi/uniffi-dart-bindgen/Cargo.toml b/uniffi/uniffi-dart-bindgen/Cargo.toml new file mode 100644 index 000000000..31133c961 --- /dev/null +++ b/uniffi/uniffi-dart-bindgen/Cargo.toml @@ -0,0 +1,12 @@ +[package] +name = "uniffi-dart-bindgen" +version = "0.1.0" +edition = "2021" +publish = false + +[[bin]] +name = "uniffi-dart-bindgen" +path = "src/uniffi-bindgen.rs" + +[dependencies] +uniffi = { git = "https://github.com/NiallBunting/uniffi-rs-dart.git", features = ["cli"] } diff --git a/uniffi/uniffi-dart-bindgen/src/uniffi-bindgen.rs b/uniffi/uniffi-dart-bindgen/src/uniffi-bindgen.rs new file mode 100644 index 000000000..f6cff6cf1 --- /dev/null +++ b/uniffi/uniffi-dart-bindgen/src/uniffi-bindgen.rs @@ -0,0 +1,3 @@ +fn main() { + uniffi::uniffi_bindgen_main() +} diff --git a/wrappers/dart/devolutions_crypto_dart/.gitignore b/wrappers/dart/devolutions_crypto_dart/.gitignore new file mode 100644 index 000000000..3cceda557 --- /dev/null +++ b/wrappers/dart/devolutions_crypto_dart/.gitignore @@ -0,0 +1,7 @@ +# https://dart.dev/guides/libraries/private-files +# Created by `dart pub` +.dart_tool/ + +# Avoid committing pubspec.lock for library packages; see +# https://dart.dev/guides/libraries/private-files#pubspeclock. +pubspec.lock diff --git a/wrappers/dart/devolutions_crypto_dart/CHANGELOG.md b/wrappers/dart/devolutions_crypto_dart/CHANGELOG.md new file mode 100644 index 000000000..effe43c82 --- /dev/null +++ b/wrappers/dart/devolutions_crypto_dart/CHANGELOG.md @@ -0,0 +1,3 @@ +## 1.0.0 + +- Initial version. diff --git a/wrappers/dart/devolutions_crypto_dart/README.md b/wrappers/dart/devolutions_crypto_dart/README.md new file mode 100644 index 000000000..8831761b8 --- /dev/null +++ b/wrappers/dart/devolutions_crypto_dart/README.md @@ -0,0 +1,39 @@ + + +TODO: Put a short description of the package here that helps potential users +know whether this package might be useful for them. + +## Features + +TODO: List what your package can do. Maybe include images, gifs, or videos. + +## Getting started + +TODO: List prerequisites and provide or point to information on how to +start using the package. + +## Usage + +TODO: Include short and useful examples for package users. Add longer examples +to `/example` folder. + +```dart +const like = 'sample'; +``` + +## Additional information + +TODO: Tell users more about the package: where to find more information, how to +contribute to the package, how to file issues, what response they can expect +from the package authors, and more. diff --git a/wrappers/dart/devolutions_crypto_dart/analysis_options.yaml b/wrappers/dart/devolutions_crypto_dart/analysis_options.yaml new file mode 100644 index 000000000..dee8927aa --- /dev/null +++ b/wrappers/dart/devolutions_crypto_dart/analysis_options.yaml @@ -0,0 +1,30 @@ +# This file configures the static analysis results for your project (errors, +# warnings, and lints). +# +# This enables the 'recommended' set of lints from `package:lints`. +# This set helps identify many issues that may lead to problems when running +# or consuming Dart code, and enforces writing Dart using a single, idiomatic +# style and format. +# +# If you want a smaller set of lints you can change this to specify +# 'package:lints/core.yaml'. These are just the most critical lints +# (the recommended set includes the core lints). +# The core lints are also what is used by pub.dev for scoring packages. + +include: package:lints/recommended.yaml + +# Uncomment the following section to specify additional rules. + +# linter: +# rules: +# - camel_case_types + +# analyzer: +# exclude: +# - path/to/excluded/files/** + +# For more information about the core and recommended set of lints, see +# https://dart.dev/go/core-lints + +# For additional information about configuring this file, see +# https://dart.dev/guides/language/analysis-options diff --git a/wrappers/dart/devolutions_crypto_dart/lib/devolutions_crypto.dart b/wrappers/dart/devolutions_crypto_dart/lib/devolutions_crypto.dart new file mode 100644 index 000000000..4ebedf976 --- /dev/null +++ b/wrappers/dart/devolutions_crypto_dart/lib/devolutions_crypto.dart @@ -0,0 +1,4268 @@ +// This file was autogenerated by some hot garbage in the `uniffi` crate. +// Trust me, you don't want to mess with it! +// +// Common helper code. +// +// Ideally this would live in a separate .dart file where it can be unittested etc +// in isolation, and perhaps even published as a re-useable package. +// +// However, it's important that the details of how this helper code works (e.g. the +// way that different builtin types are passed across the FFI) exactly match what's +// expected by the rust code on the other side of the interface. In practice right +// now that means coming from the exact some version of `uniffi` that was used to +// compile the rust component. The easiest way to ensure this is to bundle the Python +// helpers directly inline like we're doing here. + +import 'dart:ffi'; +import 'package:ffi/ffi.dart'; +import 'dart:io'; +import 'dart:async'; +import 'package:mutex/mutex.dart'; +import 'dart:typed_data'; + +// Used for default argument values +//_DEFAULT = object() + + +final class _UniffiRustBuffer extends Struct { + @Uint32() + external int capacity; + + @Uint32() + external int len; + + external Pointer data; + + _UniffiRustBufferBuilder get buffer => _UniffiRustBufferBuilder.fromStrData(data, len); +} + +//class _UniffiForeignBytes(ctypes.Structure): +// _fields_ = [ +// ("len", ctypes.c_int32), +// ("data", ctypes.POINTER(ctypes.c_char)), +// ] +// +// def __str__(self): +// return "_UniffiForeignBytes(len={}, data={})".format(self.len, self.data[0:self.len]) +// +// +//class _UniffiRustBufferStream { +// Pointer pointer; +// int length; +// +// _UniffiRustBufferStream(this.pointer, this.length); +// +//} +// """ +// Helper for structured reading of bytes from a _UniffiRustBuffer +// """ +// +// def __init__(self, data, len): +// self.data = data +// self.len = len +// self.offset = 0 +// +// @classmethod +// def from_rust_buffer(cls, buf): +// return cls(buf.data, buf.len) +// +// def remaining(self): +// return self.len - self.offset +// +// def _unpack_from(self, size, format): +// if self.offset + size > self.len: +// raise InternalError("read past end of rust buffer") +// value = struct.unpack(format, self.data[self.offset:self.offset+size])[0] +// self.offset += size +// return value +// +// def read(self, size): +// if self.offset + size > self.len: +// raise InternalError("read past end of rust buffer") +// data = self.data[self.offset:self.offset+size] +// self.offset += size +// return data +// +// def read_i8(self): +// return self._unpack_from(1, ">b") +// +// def read_u8(self): +// return self._unpack_from(1, ">B") +// +// def read_i16(self): +// return self._unpack_from(2, ">h") +// +// def read_u16(self): +// return self._unpack_from(2, ">H") +// +// def read_i32(self): +// return self._unpack_from(4, ">i") +// +// def read_u32(self): +// return self._unpack_from(4, ">I") +// +// def read_i64(self): +// return self._unpack_from(8, ">q") +// +// def read_u64(self): +// return self._unpack_from(8, ">Q") +// +// def read_float(self): +// v = self._unpack_from(4, ">f") +// return v +// +// def read_double(self): +// return self._unpack_from(8, ">d") +// +// def read_c_size_t(self): +// return self._unpack_from(ctypes.sizeof(ctypes.c_size_t) , "@N") +// +class _UniffiRustBufferBuilder { + + late ByteData buffer; + late int len; + int offset = 0; + + _UniffiRustBufferBuilder([int len = 16]) { + this.offset = 0; + this.buffer = ByteData(len); + this.len = len; + } + + _UniffiRustBufferBuilder.fromData(Pointer data, int len) { + this.offset = 0; + this.len = len; + this.buffer = data.asTypedList(len).buffer.asByteData(0); + } + + _UniffiRustBufferBuilder.fromStrData(Pointer data, int len) { + this.offset = 0; + this.len = len; + this.buffer = data.cast().asTypedList(len).buffer.asByteData(0); + } + + int get length => offset; + + Pointer toNativeUtf8() { + final uint8List = buffer.buffer.asUint8List(); + final result = calloc(this.offset); + + for (var i = 0; i < this.offset; ++i) { + result[i] = uint8List[i]; + } + + return result.cast(); + } + + String toDartString(int? size) { + int end = len; + if (size != null) { + end = offset + size; + if (end > len) { + throw "Longer than string"; + } + } + + var sublist = Uint8List.sublistView(buffer, offset, end); + + offset = end; + return String.fromCharCodes(sublist); + + } + + _unpack() { + + } + + read_u8() { + if (this.offset + 1 > this.len) { + throw "Not enough bytes."; + } + var retVal = buffer.getUint8(this.offset); + this.offset += 1; + return retVal; + } + + write_u8(value) { + if (this.offset + 1 > this.len) { + throw "Not enough bytes."; + } + buffer.setUint8(this.offset, value); + this.offset += 1; + } + + read_i32() { + if (this.offset + 4 > this.len) { + throw "Not enough bytes."; + } + var retVal = buffer.getInt32(this.offset, Endian.big); + this.offset += 4; + return retVal; + } + + write_i32(value) { + if (this.offset + 4 > this.len) { + throw "Not enough bytes."; + } + buffer.setInt32(this.offset, value, Endian.big); + this.offset += 4; + } + + read_u16() { + if (this.offset + 2 > this.len) { + throw "Not enough bytes."; + } + var retVal = buffer.getUint16(this.offset, Endian.big); + this.offset += 2; + return retVal; + } + + write_u16(value) { + if (this.offset + 2 > this.len) { + throw "Not enough bytes."; + } + buffer.setUint16(this.offset, value, Endian.big); + this.offset += 2; + } + + read_u32() { + if (this.offset + 4 > this.len) { + throw "Not enough bytes."; + } + var retVal = buffer.getUint32(this.offset, Endian.big); + this.offset += 4; + return retVal; + } + + read_u64() { + if (this.offset + 8 > this.len) { + throw "Not enough bytes."; + } + var retVal = buffer.getUint64(this.offset, Endian.big); + this.offset += 8; + return retVal; + } + + read_i64() { + if (this.offset + 8 > this.len) { + throw "Not enough bytes."; + } + var retVal = buffer.getInt64(this.offset, Endian.big); + this.offset += 8; + return retVal; + } + + read_double() { + if (this.offset + 8 > this.len) { + throw "Not enough bytes."; + } + var retVal = buffer.getFloat64(this.offset, Endian.big); + this.offset += 8; + return retVal; + } +} +// """ +// Helper for structured writing of bytes into a _UniffiRustBuffer. +// """ +// +// def __init__(self): +// self.rbuf = _UniffiRustBuffer.alloc(16) +// self.rbuf.len = 0 +// +// def finalize(self): +// rbuf = self.rbuf +// self.rbuf = None +// return rbuf +// +// def discard(self): +// if self.rbuf is not None: +// rbuf = self.finalize() +// rbuf.free() +// +// @contextlib.contextmanager +// def _reserve(self, num_bytes): +// if self.rbuf.len + num_bytes > self.rbuf.capacity: +// self.rbuf = _UniffiRustBuffer.reserve(self.rbuf, num_bytes) +// yield None +// self.rbuf.len += num_bytes +// +// def _pack_into(self, size, format, value): +// with self._reserve(size): +// # XXX TODO: I feel like I should be able to use `struct.pack_into` here but can't figure it out. +// for i, byte in enumerate(struct.pack(format, value)): +// self.rbuf.data[self.rbuf.len + i] = byte +// +// def write(self, value): +// with self._reserve(len(value)): +// for i, byte in enumerate(value): +// self.rbuf.data[self.rbuf.len + i] = byte +// +// def write_i8(self, v): +// self._pack_into(1, ">b", v) +// +// def write_u8(self, v): +// self._pack_into(1, ">B", v) +// +// def write_i16(self, v): +// self._pack_into(2, ">h", v) +// +// def write_u16(self, v): +// self._pack_into(2, ">H", v) +// +// def write_i32(self, v): +// self._pack_into(4, ">i", v) +// +// def write_u32(self, v): +// self._pack_into(4, ">I", v) +// +// def write_i64(self, v): +// self._pack_into(8, ">q", v) +// +// def write_u64(self, v): +// self._pack_into(8, ">Q", v) +// +// def write_float(self, v): +// self._pack_into(4, ">f", v) +// +// def write_double(self, v): +// self._pack_into(8, ">d", v) +// +// def write_c_size_t(self, v): +// self._pack_into(ctypes.sizeof(ctypes.c_size_t) , "@N", v) +// A handful of classes and functions to support the generated data structures. +// This would be a good candidate for isolating in its own ffi-support lib. + +final class _UniffiRustCallStatus extends Struct { + @Uint8() + external int code; + + external _UniffiRustBuffer error_buf; +} + + + +enum RUST_CALL_STATUS { CALL_SUCCESS, CALL_ERROR, CALL_PANIC } + + +// This is just a wrapper +_rustCall(fn, rustCallStatus) { + return _rustCallWithError(null, fn, rustCallStatus); +} + +// This is just a wrapper +_rustCallWithError(_UniffiWithError? error, fn, Pointer<_UniffiRustCallStatus> rustCallStatus) { + var fnResult = fn(); + + _rustCallCheckStatus(error, rustCallStatus); + + calloc.free(rustCallStatus); + return fnResult; +} + +void _rustCallCheckStatus(_UniffiWithError? error, Pointer<_UniffiRustCallStatus> rustCallStatus) { + if (rustCallStatus.ref.code == RUST_CALL_STATUS.CALL_SUCCESS.index) { + return; + } else if (rustCallStatus.ref.code == RUST_CALL_STATUS.CALL_ERROR.index) { + if(error == null) { + throw 'CALL_ERROR but error converter is null.'; + } else { + throw error.toError(rustCallStatus); + } + } else if (rustCallStatus.ref.code == RUST_CALL_STATUS.CALL_PANIC.index) { + throw 'Panic: Rust Panic: ${rustCallStatus.ref.error_buf.data.toDartString()}'; + } else { + throw 'PANIC: rustCallStatus.ref.code undefined value: ${rustCallStatus.ref.code}'; + } +} + +//class InternalError(Exception): +// pass +// +//class _UniffiRustCallStatus(ctypes.Structure): +// """ +// Error runtime. +// """ +// _fields_ = [ +// ("code", ctypes.c_int8), +// ("error_buf", _UniffiRustBuffer), +// ] +// +// # These match the values from the uniffi::rustcalls module +// CALL_SUCCESS = 0 +// CALL_ERROR = 1 +// CALL_PANIC = 2 +// +// def __str__(self): +// if self.code == _UniffiRustCallStatus.CALL_SUCCESS: +// return "_UniffiRustCallStatus(CALL_SUCCESS)" +// elif self.code == _UniffiRustCallStatus.CALL_ERROR: +// return "_UniffiRustCallStatus(CALL_ERROR)" +// elif self.code == _UniffiRustCallStatus.CALL_PANIC: +// return "_UniffiRustCallStatus(CALL_PANIC)" +// else: +// return "_UniffiRustCallStatus()" +// +//def _rust_call(fn, *args): +// # Call a rust function +// return _rust_call_with_error(None, fn, *args) +// +//def _rust_call_with_error(error_ffi_converter, fn, *args): +// # Call a rust function and handle any errors +// # +// # This function is used for rust calls that return Result<> and therefore can set the CALL_ERROR status code. +// # error_ffi_converter must be set to the _UniffiConverter for the error class that corresponds to the result. +// call_status = _UniffiRustCallStatus(code=_UniffiRustCallStatus.CALL_SUCCESS, error_buf=_UniffiRustBuffer(0, 0, None)) +// +// args_with_error = args + (ctypes.byref(call_status),) +// result = fn(*args_with_error) +// _uniffi_check_call_status(error_ffi_converter, call_status) +// return result +// +//def _uniffi_check_call_status(error_ffi_converter, call_status): +// if call_status.code == _UniffiRustCallStatus.CALL_SUCCESS: +// pass +// elif call_status.code == _UniffiRustCallStatus.CALL_ERROR: +// if error_ffi_converter is None: +// call_status.error_buf.free() +// raise InternalError("_rust_call_with_error: CALL_ERROR, but error_ffi_converter is None") +// else: +// raise error_ffi_converter.lift(call_status.error_buf) +// elif call_status.code == _UniffiRustCallStatus.CALL_PANIC: +// # When the rust code sees a panic, it tries to construct a _UniffiRustBuffer +// # with the message. But if that code panics, then it just sends back +// # an empty buffer. +// if call_status.error_buf.len > 0: +// msg = _UniffiConverterString.lift(call_status.error_buf) +// else: +// msg = "Unknown rust panic" +// raise InternalError(msg) +// else: +// raise InternalError("Invalid _UniffiRustCallStatus code: {}".format( +// call_status.code)) +// +//# A function pointer for a callback as defined by UniFFI. +//# Rust definition `fn(handle: u64, method: u32, args: _UniffiRustBuffer, buf_ptr: *mut _UniffiRustBuffer) -> int` +//_UNIFFI_FOREIGN_CALLBACK_T = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_ulonglong, ctypes.c_ulong, ctypes.POINTER(ctypes.c_char), ctypes.c_int, ctypes.POINTER(_UniffiRustBuffer)) +// +//# UniFFI future continuation +//_UNIFFI_FUTURE_CONTINUATION_T = ctypes.CFUNCTYPE(None, ctypes.c_size_t, ctypes.c_int8) +// +// Types conforming to `_UniffiConverterPrimitive` pass themselves directly over the FFI. +class _UniffiConverterPrimitive { + static check(value) { + return true; + } + + lift(value) { + return value; + } + + lower(value) { + return value; + } +} + +class _UniffiConverterPrimitiveInt extends _UniffiConverterPrimitive { + //@classmethod + //def check(cls, value): + // try: + // value = value.__index__() + // except Exception: + // raise TypeError("'{}' object cannot be interpreted as an integer".format(type(value).__name__)) + // if not isinstance(value, int): + // raise TypeError("__index__ returned non-int (type {})".format(type(value).__name__)) + // if not cls.VALUE_MIN <= value < cls.VALUE_MAX: + // raise ValueError("{} requires {} <= value < {}".format(cls.CLASS_NAME, cls.VALUE_MIN, cls.VALUE_MAX)) + // return super().check(value) + + static write_unchecked(value, buf) { + return value; + } +} + +class _UniffiConverterPrimitiveFloat extends _UniffiConverterPrimitive { + //@classmethod + //def check(cls, value): + // try: + // value = value.__float__() + // except Exception: + // raise TypeError("must be real number, not {}".format(type(value).__name__)) + // if not isinstance(value, float): + // raise TypeError("__float__ returned non-float (type {})".format(type(value).__name__)) + // return super().check(value) + + static write_unchecked(value, buf) { + return value; + } +} + +// Helper class for wrapper types that will always go through a _UniffiRustBuffer. +// Classes should inherit from this and implement the `read` and `write` static methods. +abstract interface class _UniffiConverterRustBuffer { + + Pointer<_UniffiRustBuffer>? _rustBuffer; + + T lift(_UniffiRustBuffer buf) { + return read(buf.buffer); + } + + _UniffiRustBuffer lower(T value) { + + var bufferBuilder = _UniffiRustBufferBuilder(); + write(bufferBuilder, value); + + _rustBuffer = calloc<_UniffiRustBuffer >(); + _rustBuffer!.ref + ..capacity = bufferBuilder.length + ..len = bufferBuilder.length + ..data = bufferBuilder.toNativeUtf8(); + + return _rustBuffer!.ref; + } + + T read(_UniffiRustBufferBuilder buf); + + write(_UniffiRustBufferBuilder buf, T value); + + void dispose() { + if (_rustBuffer != null) { + calloc.free(this._rustBuffer!); + } + } +} + +class _UniffiWithError { + static _UniffiRustBuffer lift(Pointer<_UniffiRustCallStatus> val) { + return val.ref.error_buf; + } + + @override + liftNotStatic(Pointer<_UniffiRustCallStatus> buf) { + return lift(buf); + } + + toError(Pointer<_UniffiRustCallStatus> val) { + } + static read(_UniffiRustBuffer buf) { + return buf; + } +} + +// Contains loading, initialization code, and the FFI Function declarations. +//# Define some ctypes FFI types that we use in the library +// +//""" +//ctypes type for the foreign executor callback. This is a built-in interface for scheduling +//tasks +// +//Args: +// executor: opaque c_size_t value representing the eventloop +// delay: delay in ms +// task: function pointer to the task callback +// task_data: void pointer to the task callback data +// +//Normally we should call task(task_data) after the detail. +//However, when task is NULL this indicates that Rust has dropped the ForeignExecutor and we should +//decrease the EventLoop refcount. +//""" +//_UNIFFI_FOREIGN_EXECUTOR_CALLBACK_T = ctypes.CFUNCTYPE(ctypes.c_int8, ctypes.c_size_t, ctypes.c_uint32, ctypes.c_void_p, ctypes.c_void_p) +// +//""" +//Function pointer for a Rust task, which a callback function that takes a opaque pointer +//""" +//_UNIFFI_RUST_TASK = ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_int8) +// +//def _uniffi_future_callback_t(return_type): +// """ +// Factory function to create callback function types for async functions +// """ +// return ctypes.CFUNCTYPE(None, ctypes.c_size_t, return_type, _UniffiRustCallStatus) +// +//def _uniffi_load_indirect(): +// """ +// This is how we find and load the dynamic library provided by the component. +// For now we just look it up by name. +// """ +// if sys.platform == "darwin": +// libname = "lib{}.dylib" +// elif sys.platform.startswith("win"): +// # As of python3.8, ctypes does not seem to search $PATH when loading DLLs. +// # We could use `os.add_dll_directory` to configure the search path, but +// # it doesn't feel right to mess with application-wide settings. Let's +// # assume that the `.dll` is next to the `.py` file and load by full path. +// libname = os.path.join( +// os.path.dirname(__file__), +// "{}.dll", +// ) +// else: +// # Anything else must be an ELF platform - Linux, *BSD, Solaris/illumos +// libname = "lib{}.so" +// +// libname = libname.format("uniffi_devolutions_crypto") +// path = os.path.join(os.path.dirname(__file__), libname) +// lib = ctypes.cdll.LoadLibrary(path) +// return lib + +DynamicLibrary _uniffiLoadDynamicLibrary() { + + final path = Platform.isWindows ? "libuniffi_devolutions_crypto.dll" : "libuniffi_devolutions_crypto.so"; + var lib = Platform.isIOS + ? DynamicLibrary.process() + : Platform.isMacOS + ? DynamicLibrary.executable() + : DynamicLibrary.open(path); + + _uniffi_check_contract_api_version(lib); + + return lib; +} + +final _uniffiLib = _uniffiLoadDynamicLibrary(); +// +_uniffi_check_contract_api_version(DynamicLibrary lib) { + + _UniffiLib_ffi_devolutions_crypto_uniffi_dart_uniffi_contract_version_d contractFunc = lib.lookup>('ffi_devolutions_crypto_uniffi_dart_uniffi_contract_version').asFunction(); + + // Get the bindings contract version from our ComponentInterface + var bindings_contract_version = 24; + // Get the scaffolding contract version by calling the into the dylib + var scaffolding_contract_version = contractFunc(); + + if (bindings_contract_version != scaffolding_contract_version) { + throw "UniFFI contract version mismatch: try cleaning and rebuilding your project"; + } +} +// +//def _uniffi_check_api_checksums(lib): +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt() != 55904: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric() != 15240: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric_with_aad() != 1857: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_with_aad() != 45000: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_keypair() != 18544: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_shared_key() != 50867: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_signing_keypair() != 55208: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_hash_password() != 10906: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_sign() != 41188: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode() != 56702: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode_url() != 9630: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode() != 50003: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode_url() != 52047: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt() != 21256: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric() != 36047: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric_with_aad() != 40151: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_with_aad() != 3739: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_argon2() != 18583: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_pbkdf2() != 31088: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_key() != 48512: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_join_shares() != 35818: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_mix_key_exchange() != 42430: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_validate_header() != 36935: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_password() != 43457: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_signature() != 36969: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parameters_get_bytes() != 41797: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_associated_data() != 52063: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_build() != 35155: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_dc_version() != 43928: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_iterations() != 26358: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_lanes() != 35813: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_length() != 29728: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_memory() != 54738: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_salt() != 60249: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_secret_key() != 42733: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_variant() != 44924: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_version() != 19643: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_private_key() != 59578: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_public_key() != 54920: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parameters_new_from_bytes() != 13354: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parametersbuilder_new() != 13663: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// if lib.uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_signingkeypair_new_from_bytes() != 64102: +// raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project") +// +// +//# A ctypes library to expose the extern-C FFI definitions. +//# This is an implementation detail which will be called internally by the public API. +// + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parameters_c = Void Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parameters_d = void Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parameters_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parameters_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parameters').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parameters_new_from_bytes_c = Pointer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parameters_new_from_bytes_d = Pointer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parameters_new_from_bytes_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parameters_new_from_bytes_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parameters_new_from_bytes').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parameters_get_bytes_c = _UniffiRustBuffer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parameters_get_bytes_d = _UniffiRustBuffer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parameters_get_bytes_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parameters_get_bytes_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parameters_get_bytes').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parametersbuilder_c = Void Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parametersbuilder_d = void Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parametersbuilder_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parametersbuilder_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parametersbuilder').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parametersbuilder_new_c = Pointer Function( + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parametersbuilder_new_d = Pointer Function( + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parametersbuilder_new_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parametersbuilder_new_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parametersbuilder_new').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_associated_data_c = Pointer Function( + Pointer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_associated_data_d = Pointer Function( + Pointer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_associated_data_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_associated_data_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_associated_data').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_build_c = Pointer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_build_d = Pointer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_build_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_build_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_build').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_dc_version_c = Pointer Function( + Pointer, + Uint32, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_dc_version_d = Pointer Function( + Pointer, + int, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_dc_version_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_dc_version_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_dc_version').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_iterations_c = Pointer Function( + Pointer, + Uint32, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_iterations_d = Pointer Function( + Pointer, + int, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_iterations_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_iterations_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_iterations').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_lanes_c = Pointer Function( + Pointer, + Uint32, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_lanes_d = Pointer Function( + Pointer, + int, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_lanes_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_lanes_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_lanes').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_length_c = Pointer Function( + Pointer, + Uint32, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_length_d = Pointer Function( + Pointer, + int, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_length_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_length_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_length').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_memory_c = Pointer Function( + Pointer, + Uint32, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_memory_d = Pointer Function( + Pointer, + int, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_memory_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_memory_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_memory').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_salt_c = Pointer Function( + Pointer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_salt_d = Pointer Function( + Pointer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_salt_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_salt_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_salt').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_secret_key_c = Pointer Function( + Pointer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_secret_key_d = Pointer Function( + Pointer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_secret_key_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_secret_key_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_secret_key').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_variant_c = Pointer Function( + Pointer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_variant_d = Pointer Function( + Pointer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_variant_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_variant_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_variant').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_version_c = Pointer Function( + Pointer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_version_d = Pointer Function( + Pointer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_version_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_version_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_version').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_signingkeypair_c = Void Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_signingkeypair_d = void Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_signingkeypair_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_signingkeypair_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_free_signingkeypair').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_signingkeypair_new_from_bytes_c = Pointer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_signingkeypair_new_from_bytes_d = Pointer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_signingkeypair_new_from_bytes_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_signingkeypair_new_from_bytes_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_constructor_signingkeypair_new_from_bytes').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_private_key_c = _UniffiRustBuffer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_private_key_d = _UniffiRustBuffer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_private_key_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_private_key_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_private_key').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_public_key_c = _UniffiRustBuffer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_public_key_d = _UniffiRustBuffer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_public_key_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_public_key_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_public_key').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_with_aad_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_with_aad_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_with_aad_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_with_aad_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_with_aad').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_with_aad_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_with_aad_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_with_aad_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_with_aad_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_with_aad').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_keypair_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_keypair_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_keypair_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_keypair_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_keypair').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_shared_key_c = _UniffiRustBuffer Function( + Uint8, + Uint8, + Uint32, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_shared_key_d = _UniffiRustBuffer Function( + int, + int, + int, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_shared_key_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_shared_key_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_shared_key').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_signing_keypair_c = Pointer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_signing_keypair_d = Pointer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_signing_keypair_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_signing_keypair_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_signing_keypair').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_hash_password_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Uint32, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_hash_password_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + int, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_hash_password_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_hash_password_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_hash_password').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_sign_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_sign_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_sign_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_sign_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_sign').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_url_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_url_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_url_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_url_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_url').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_url_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_url_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_url_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_url_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_url').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_with_aad_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_with_aad_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_with_aad_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_with_aad_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_with_aad').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_with_aad_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_with_aad_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_with_aad_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_with_aad_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_with_aad').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_argon2_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_argon2_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_argon2_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_argon2_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_argon2').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_pbkdf2_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Uint32, + Uint32, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_pbkdf2_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + int, + int, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_pbkdf2_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_pbkdf2_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_pbkdf2').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_key_c = _UniffiRustBuffer Function( + Uint32, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_key_d = _UniffiRustBuffer Function( + int, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_key_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_key_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_key').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_join_shares_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_join_shares_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_join_shares_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_join_shares_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_join_shares').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_mix_key_exchange_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_mix_key_exchange_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_mix_key_exchange_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_mix_key_exchange_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_mix_key_exchange').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_validate_header_c = Int8 Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_validate_header_d = int Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_validate_header_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_validate_header_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_validate_header').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_password_c = Int8 Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_password_d = int Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_password_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_password_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_password').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_signature_c = Int8 Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_signature_d = int Function( + _UniffiRustBuffer, + _UniffiRustBuffer, + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_signature_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_signature_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_signature').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_alloc_c = _UniffiRustBuffer Function( + Int32, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_alloc_d = _UniffiRustBuffer Function( + int, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_alloc_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_alloc_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rustbuffer_alloc').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_from_bytes_c = _UniffiRustBuffer Function( + Pointer<_UniffiRustCallStatus>, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_from_bytes_d = _UniffiRustBuffer Function( + Pointer<_UniffiRustCallStatus>, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_from_bytes_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_from_bytes_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rustbuffer_from_bytes').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_free_c = Void Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_free_d = void Function( + _UniffiRustBuffer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_free_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_free_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rustbuffer_free').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_reserve_c = _UniffiRustBuffer Function( + _UniffiRustBuffer, + Int32, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_reserve_d = _UniffiRustBuffer Function( + _UniffiRustBuffer, + int, + Pointer<_UniffiRustCallStatus>, +); + +typedef _continationCallbackTypedef = Void Function(Int32 ptr, Int32 i); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_reserve_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rustbuffer_reserve_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rustbuffer_reserve').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_continuation_callback_set_c = Void Function( + Pointer>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_continuation_callback_set_d = void Function( + Pointer>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_continuation_callback_set_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_continuation_callback_set_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_continuation_callback_set').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u8_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u8_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u8_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u8_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u8').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u8_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u8_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u8_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u8_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u8').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u8_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u8_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u8_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u8_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_u8').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u8_c = Uint8 Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u8_d = int Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u8_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u8_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u8').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i8_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i8_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i8_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i8_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i8').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i8_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i8_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i8_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i8_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i8').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i8_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i8_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i8_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i8_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_i8').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i8_c = Int8 Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i8_d = int Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i8_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i8_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i8').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u16_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u16_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u16_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u16_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u16').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u16_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u16_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u16_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u16_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u16').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u16_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u16_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u16_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u16_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_u16').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u16_c = Uint16 Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u16_d = int Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u16_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u16_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u16').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i16_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i16_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i16_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i16_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i16').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i16_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i16_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i16_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i16_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i16').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i16_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i16_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i16_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i16_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_i16').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i16_c = Int16 Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i16_d = int Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i16_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i16_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i16').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u32_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u32_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u32_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u32_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u32_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u32_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_u32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u32_c = Uint32 Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u32_d = int Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i32_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i32_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i32_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i32_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i32_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i32_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_i32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i32_c = Int32 Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i32_d = int Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u64_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u64_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_u64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u64_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u64_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_u64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u64_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u64_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_u64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_u64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u64_c = Uint64 Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u64_d = int Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_u64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i64_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i64_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_i64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i64_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i64_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_i64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i64_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i64_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_i64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_i64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i64_c = Int64 Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i64_d = int Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_i64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_f32_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_f32_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_f32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_f32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_f32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_f32_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_f32_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_f32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_f32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_f32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_f32_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_f32_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_f32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_f32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_f32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_f32_c = Float Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_f32_d = double Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_f32_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_f32_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_f32').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_f64_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_f64_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_f64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_f64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_f64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_f64_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_f64_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_f64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_f64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_f64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_f64_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_f64_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_f64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_f64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_f64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_f64_c = Double Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_f64_d = double Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_f64_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_f64_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_f64').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_pointer_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_pointer_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_pointer_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_pointer_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_pointer').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_pointer_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_pointer_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_pointer_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_pointer_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_pointer').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_pointer_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_pointer_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_pointer_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_pointer_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_pointer').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_pointer_c = Pointer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_pointer_d = Pointer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_pointer_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_pointer_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_pointer').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_rust_buffer_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_rust_buffer_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_rust_buffer_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_rust_buffer_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_rust_buffer').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_rust_buffer_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_rust_buffer_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_rust_buffer_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_rust_buffer_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_rust_buffer').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_rust_buffer_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_rust_buffer_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_rust_buffer_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_rust_buffer_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_rust_buffer').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_rust_buffer_c = _UniffiRustBuffer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_rust_buffer_d = _UniffiRustBuffer Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_rust_buffer_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_rust_buffer_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_rust_buffer').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_void_c = Void Function( + Pointer, + Size, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_void_d = void Function( + Pointer, + int, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_void_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_poll_void_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_poll_void').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_void_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_void_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_void_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_void_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_cancel_void').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_void_c = Void Function( + Pointer, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_void_d = void Function( + Pointer, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_void_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_free_void_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_free_void').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_void_c = Void Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_void_d = void Function( + Pointer, + Pointer<_UniffiRustCallStatus>, +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_void_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_rust_future_complete_void_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_rust_future_complete_void').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric_with_aad_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric_with_aad_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric_with_aad_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric_with_aad_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_asymmetric_with_aad').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_with_aad_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_with_aad_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_with_aad_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_with_aad_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_encrypt_with_aad').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_keypair_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_keypair_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_keypair_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_keypair_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_keypair').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_shared_key_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_shared_key_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_shared_key_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_shared_key_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_shared_key').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_signing_keypair_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_signing_keypair_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_signing_keypair_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_signing_keypair_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_signing_keypair').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_hash_password_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_hash_password_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_hash_password_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_hash_password_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_hash_password').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_sign_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_sign_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_sign_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_sign_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_sign').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode_url_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode_url_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode_url_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode_url_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_decode_url').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode_url_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode_url_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode_url_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode_url_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_base64_encode_url').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric_with_aad_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric_with_aad_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric_with_aad_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric_with_aad_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_asymmetric_with_aad').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_with_aad_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_with_aad_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_with_aad_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_with_aad_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_decrypt_with_aad').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_argon2_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_argon2_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_argon2_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_argon2_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_argon2').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_pbkdf2_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_pbkdf2_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_pbkdf2_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_pbkdf2_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_derive_key_pbkdf2').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_key_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_key_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_key_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_key_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_generate_key').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_join_shares_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_join_shares_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_join_shares_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_join_shares_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_join_shares').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_mix_key_exchange_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_mix_key_exchange_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_mix_key_exchange_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_mix_key_exchange_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_mix_key_exchange').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_validate_header_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_validate_header_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_validate_header_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_validate_header_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_validate_header').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_password_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_password_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_password_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_password_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_password').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_signature_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_signature_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_signature_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_signature_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_func_verify_signature').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parameters_get_bytes_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parameters_get_bytes_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parameters_get_bytes_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parameters_get_bytes_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parameters_get_bytes').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_associated_data_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_associated_data_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_associated_data_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_associated_data_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_associated_data').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_build_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_build_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_build_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_build_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_build').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_dc_version_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_dc_version_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_dc_version_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_dc_version_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_dc_version').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_iterations_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_iterations_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_iterations_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_iterations_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_iterations').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_lanes_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_lanes_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_lanes_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_lanes_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_lanes').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_length_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_length_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_length_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_length_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_length').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_memory_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_memory_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_memory_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_memory_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_memory').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_salt_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_salt_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_salt_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_salt_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_salt').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_secret_key_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_secret_key_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_secret_key_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_secret_key_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_secret_key').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_variant_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_variant_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_variant_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_variant_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_variant').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_version_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_version_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_version_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_version_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_argon2parametersbuilder_version').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_private_key_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_private_key_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_private_key_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_private_key_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_private_key').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_public_key_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_public_key_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_public_key_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_public_key_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_method_signingkeypair_get_public_key').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parameters_new_from_bytes_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parameters_new_from_bytes_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parameters_new_from_bytes_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parameters_new_from_bytes_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parameters_new_from_bytes').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parametersbuilder_new_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parametersbuilder_new_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parametersbuilder_new_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parametersbuilder_new_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_argon2parametersbuilder_new').asFunction(); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_signingkeypair_new_from_bytes_c = Uint16 Function( +); + +typedef _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_signingkeypair_new_from_bytes_d = int Function( +); + +final _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_signingkeypair_new_from_bytes_d _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_signingkeypair_new_from_bytes_func = _uniffiLib.lookup>('uniffi_devolutions_crypto_uniffi_dart_checksum_constructor_signingkeypair_new_from_bytes').asFunction(); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_uniffi_contract_version_c = Uint32 Function( +); + +typedef _UniffiLib_ffi_devolutions_crypto_uniffi_dart_uniffi_contract_version_d = int Function( +); + +final _UniffiLib_ffi_devolutions_crypto_uniffi_dart_uniffi_contract_version_d _UniffiLib_ffi_devolutions_crypto_uniffi_dart_uniffi_contract_version_func = _uniffiLib.lookup>('ffi_devolutions_crypto_uniffi_dart_uniffi_contract_version').asFunction(); + +////_uniffi_check_contract_api_version(_UniffiLib) +//_uniffi_check_api_checksums(_UniffiLib) + +// Public interface members begin here. + + +class _UniffiConverterUInt8 extends _UniffiConverterPrimitiveInt { + + + int read(_UniffiRustBufferBuilder buf) { + return buf.read_u8(); + } + + _UniffiRustBufferBuilder write(int value) { + //buf.data.cast = value; + Pointer<_UniffiRustBuffer> _rustBuffer = calloc<_UniffiRustBuffer >(); + return _rustBuffer.ref.buffer; + } +} + +class _UniffiConverterUInt32 extends _UniffiConverterPrimitiveInt { + + + int read(_UniffiRustBufferBuilder buf) { + return buf.read_u32(); + } + + _UniffiRustBufferBuilder write(int value) { + //buf.data.cast = value; + Pointer<_UniffiRustBuffer> _rustBuffer = calloc<_UniffiRustBuffer >(); + return _rustBuffer.ref.buffer; + } +} + +class _UniffiConverterBool extends _UniffiConverterPrimitive { + + @override + bool read(buf) { + return lift(buf.read_u8()); + } + + @override + _UniffiRustBufferBuilder write(bool value, _UniffiRustBufferBuilder buf) { + if(value) { + return buf.write_u8(1); + } else { + return buf.write_u8(0); + } + } + + @override + bool lift(dynamic value) { + return value != 0; + } + //bool read(_UniffiRustBufferBuilder buf) { + // return buf.read_u8() == 1; + //} + + //_UniffiRustBufferBuilder write(bool value) { + // Pointer<_UniffiRustBuffer> _rustBuffer = calloc<_UniffiRustBuffer >(); + // return _rustBuffer.ref.buffer; + // //buf.data.cast = value; + //} +} + +class _UniffiConverterString { + + late Pointer<_UniffiRustBuffer> _pointer; + + static check(value) { + /*if not isinstance(value, str): + raise TypeError("argument must be str, not {}".format(type(value).__name__)) + return value*/ + } + + String lift(_UniffiRustBuffer buf) { + return buf.data.toDartString(); + } + + _UniffiRustBuffer lower(String value) { + + _pointer = calloc<_UniffiRustBuffer>(); + _pointer.ref + ..capacity = value.length + ..len = value.length + ..data = value.toNativeUtf8(); + + return _pointer.ref; + } + + + + @override + void dispose() { + if (_pointer != null) { + calloc.free(this._pointer); + } + } + + read(_UniffiRustBufferBuilder buf) { + var size = buf.read_i32(); + if (size < 0) { + throw "Negative string length"; + } + return buf.toDartString(size); + //return utf8_bytes.decode("utf-8") + } + + _UniffiRustBufferBuilder write(String value, _UniffiRustBufferBuilder buf) { + return buf; + } +} + +class _UniffiConverterBytes extends _UniffiConverterRustBuffer { + + + write(_UniffiRustBufferBuilder buf, value){ + return buf; + } + + @override + read(_UniffiRustBufferBuilder buf) { + return buf; + } +} + + + +// Generated by Protocol +abstract class Argon2ParametersProtocol { + get_bytes() { + throw UnimplementedError('get_bytes not implemented.'); + } +} + +// Generated By: ObjectTemplate:1 +class Argon2Parameters { + //late Argon2Parameters _pointer; + late Pointer _pointer; + Pointer get pointer => _pointer; + + Argon2Parameters.fromPointer(Pointer _pointer) { + this._pointer = _pointer; + } + + @override + void dispose() { + // In case of partial initialization of instances. + if (_pointer != null) { +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parameters_func(_pointer, _rustCallStatus), _rustCallStatus); + } + } + + /*static new_from_bytes(List data) { + // + + // // Call the (fallible) function before creating any half-baked object instances. + // this._pointer = _rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parameters_new_from_bytes_func( + _UniffiConverterBytes().lower(data), + notimpl), + notimpl +); + // return make_instance_(_pointer):// TODO + //}*/ + + + // method: 2 + List get_bytes() { +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parameters_get_bytes_func(_pointer, + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + +} + +// Generated By: ObjectTemplate:2 +class _UniffiConverterTypeArgon2Parameters { + + Argon2Parameters lift(Pointer _pointer) { + // TODO: Do something with value? + return Argon2Parameters.fromPointer(_pointer); + } + + Pointer lower(Argon2Parameters value) { + return value.pointer; + } + + /* + static Argon2ParametersProtocol lower(Argon2Parameters value) { + //if not isinstance(value, Argon2Parameters): + // raise TypeError("Expected Argon2Parameters instance, {} found".format(type(value).__name__)) + //return value._pointer + return Argon2ParametersProtocol(); + }*/ + + read(_UniffiRustBufferBuilder buf) { + var ptr = buf.read_i64(); + if (ptr == 0) { + throw 'Issue with pointer'; + } + return _UniffiConverterTypeArgon2Parameters().lift(Pointer.fromAddress(ptr)); + } + + _UniffiRustBufferBuilder write(_UniffiRustBufferBuilder buf, value) { + //buf.write_u64(cls.lower(value)) + Pointer<_UniffiRustBuffer> _rustBuffer = calloc<_UniffiRustBuffer >(); + return _rustBuffer.ref.buffer; + } +} + + + +// Generated by Protocol +abstract class Argon2ParametersBuilderProtocol { + associated_data(List value) { + throw UnimplementedError('associated_data not implemented.'); + } + build() { + throw UnimplementedError('build not implemented.'); + } + dc_version(int value) { + throw UnimplementedError('dc_version not implemented.'); + } + iterations(int value) { + throw UnimplementedError('iterations not implemented.'); + } + lanes(int value) { + throw UnimplementedError('lanes not implemented.'); + } + length(int value) { + throw UnimplementedError('length not implemented.'); + } + memory(int value) { + throw UnimplementedError('memory not implemented.'); + } + salt(List value) { + throw UnimplementedError('salt not implemented.'); + } + secret_key(List value) { + throw UnimplementedError('secret_key not implemented.'); + } + variant(Argon2Variant value) { + throw UnimplementedError('variant not implemented.'); + } + version(Argon2Version value) { + throw UnimplementedError('version not implemented.'); + } +} + +// Generated By: ObjectTemplate:1 +class Argon2ParametersBuilder { + //late Argon2ParametersBuilder _pointer; + late Pointer _pointer; + Pointer get pointer => _pointer; + Argon2ParametersBuilder () { +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + _pointer = _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_argon2parametersbuilder_new_func( + _rustCallStatus), + _rustCallStatus +); + } + + Argon2ParametersBuilder.fromPointer(Pointer _pointer) { + this._pointer = _pointer; + } + + @override + void dispose() { + // In case of partial initialization of instances. + if (_pointer != null) { +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_argon2parametersbuilder_func(_pointer, _rustCallStatus), _rustCallStatus); + } + } + + // method: 2 + Argon2ParametersBuilder associated_data(List value) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2ParametersBuilder().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_associated_data_func(_pointer, + _UniffiConverterBytes().lower(value), + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + Argon2Parameters build() { +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2Parameters().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_build_func(_pointer, + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + Argon2ParametersBuilder dc_version(int value) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2ParametersBuilder().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_dc_version_func(_pointer, + _UniffiConverterUInt32().lower(value), + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + Argon2ParametersBuilder iterations(int value) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2ParametersBuilder().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_iterations_func(_pointer, + _UniffiConverterUInt32().lower(value), + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + Argon2ParametersBuilder lanes(int value) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2ParametersBuilder().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_lanes_func(_pointer, + _UniffiConverterUInt32().lower(value), + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + Argon2ParametersBuilder length(int value) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2ParametersBuilder().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_length_func(_pointer, + _UniffiConverterUInt32().lower(value), + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + Argon2ParametersBuilder memory(int value) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2ParametersBuilder().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_memory_func(_pointer, + _UniffiConverterUInt32().lower(value), + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + Argon2ParametersBuilder salt(List value) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2ParametersBuilder().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_salt_func(_pointer, + _UniffiConverterBytes().lower(value), + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + Argon2ParametersBuilder secret_key(List value) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2ParametersBuilder().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_secret_key_func(_pointer, + _UniffiConverterBytes().lower(value), + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + Argon2ParametersBuilder variant(Argon2Variant value) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2ParametersBuilder().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_variant_func(_pointer, + _UniffiConverterTypeArgon2Variant().lower(value), + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + Argon2ParametersBuilder version(Argon2Version value) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeArgon2ParametersBuilder().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_argon2parametersbuilder_version_func(_pointer, + _UniffiConverterTypeArgon2Version().lower(value), + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + +} + +// Generated By: ObjectTemplate:2 +class _UniffiConverterTypeArgon2ParametersBuilder { + + Argon2ParametersBuilder lift(Pointer _pointer) { + // TODO: Do something with value? + return Argon2ParametersBuilder.fromPointer(_pointer); + } + + Pointer lower(Argon2ParametersBuilder value) { + return value.pointer; + } + + /* + static Argon2ParametersBuilderProtocol lower(Argon2ParametersBuilder value) { + //if not isinstance(value, Argon2ParametersBuilder): + // raise TypeError("Expected Argon2ParametersBuilder instance, {} found".format(type(value).__name__)) + //return value._pointer + return Argon2ParametersBuilderProtocol(); + }*/ + + read(_UniffiRustBufferBuilder buf) { + var ptr = buf.read_i64(); + if (ptr == 0) { + throw 'Issue with pointer'; + } + return _UniffiConverterTypeArgon2ParametersBuilder().lift(Pointer.fromAddress(ptr)); + } + + _UniffiRustBufferBuilder write(_UniffiRustBufferBuilder buf, value) { + //buf.write_u64(cls.lower(value)) + Pointer<_UniffiRustBuffer> _rustBuffer = calloc<_UniffiRustBuffer >(); + return _rustBuffer.ref.buffer; + } +} + + + +// Generated by Protocol +abstract class SigningKeyPairProtocol { + get_private_key() { + throw UnimplementedError('get_private_key not implemented.'); + } + get_public_key() { + throw UnimplementedError('get_public_key not implemented.'); + } +} + +// Generated By: ObjectTemplate:1 +class SigningKeyPair { + //late SigningKeyPair _pointer; + late Pointer _pointer; + Pointer get pointer => _pointer; + + SigningKeyPair.fromPointer(Pointer _pointer) { + this._pointer = _pointer; + } + + @override + void dispose() { + // In case of partial initialization of instances. + if (_pointer != null) { +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_free_signingkeypair_func(_pointer, _rustCallStatus), _rustCallStatus); + } + } + + /*static new_from_bytes(List data) { + // + + // // Call the (fallible) function before creating any half-baked object instances. + // this._pointer = _rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_constructor_signingkeypair_new_from_bytes_func( + _UniffiConverterBytes().lower(data), + notimpl), + notimpl +); + // return make_instance_(_pointer):// TODO + //}*/ + + + // method: 2 + List get_private_key() { +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_private_key_func(_pointer, + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + + + // method: 2 + List get_public_key() { +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift( + _rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_method_signingkeypair_get_public_key_func(_pointer, + _rustCallStatus), + _rustCallStatus +) + ); + } + + + + +} + +// Generated By: ObjectTemplate:2 +class _UniffiConverterTypeSigningKeyPair { + + SigningKeyPair lift(Pointer _pointer) { + // TODO: Do something with value? + return SigningKeyPair.fromPointer(_pointer); + } + + Pointer lower(SigningKeyPair value) { + return value.pointer; + } + + /* + static SigningKeyPairProtocol lower(SigningKeyPair value) { + //if not isinstance(value, SigningKeyPair): + // raise TypeError("Expected SigningKeyPair instance, {} found".format(type(value).__name__)) + //return value._pointer + return SigningKeyPairProtocol(); + }*/ + + read(_UniffiRustBufferBuilder buf) { + var ptr = buf.read_i64(); + if (ptr == 0) { + throw 'Issue with pointer'; + } + return _UniffiConverterTypeSigningKeyPair().lift(Pointer.fromAddress(ptr)); + } + + _UniffiRustBufferBuilder write(_UniffiRustBufferBuilder buf, value) { + //buf.write_u64(cls.lower(value)) + Pointer<_UniffiRustBuffer> _rustBuffer = calloc<_UniffiRustBuffer >(); + return _rustBuffer.ref.buffer; + } +} + + +// Generated By RecordTemplate: 1 +class KeyPair { + + final List public_key; + final List private_key; + + KeyPair({ + required this.public_key + , + required this.private_key + }); + + @override + String toString() { + return "KeyPair()"; + } + + @override + bool operator ==(Object other) { + if (other is KeyPair ) { + if (public_key != other.public_key) { + return false; + } + if (private_key != other.private_key) { + return false; + } + return true; + } + return false; + } + + //@override + //int get hashCode => this.tires * this.doors; +} + +// Generated By RecordTemplate: 2 +class _UniffiConverterTypeKeyPair extends _UniffiConverterRustBuffer { + + read(_UniffiRustBufferBuilder buf) { + return KeyPair( + public_key: _UniffiConverterBytes().read(buf), + private_key: _UniffiConverterBytes().read(buf), + ); + } + + _UniffiRustBufferBuilder write(buf, value) { + /* + //_UniffiConverterBytes().write(value.public_key, buf) + //_UniffiConverterBytes().write(value.private_key, buf)*/ + return buf; + } +} + + + + + +// Enumtemplate: 1 +enum Argon2Variant { + _, + ARGON2D, + ARGON2I, + ARGON2ID, + +} + + +// Generated By: EnumTemplate: 3 +class _UniffiConverterTypeArgon2Variant extends _UniffiConverterRustBuffer { + read(_UniffiRustBufferBuilder buf) { + var variant = buf.read_i32(); + if (variant == 1) { + return Argon2Variant.ARGON2D; + } + if (variant == 2) { + return Argon2Variant.ARGON2I; + } + if (variant == 3) { + return Argon2Variant.ARGON2ID; + } + throw "Raw enum value doesn't match any cases"; + } + + write(_UniffiRustBufferBuilder buf, Argon2Variant value) { + if (value == Argon2Variant.ARGON2D) { + buf.write_i32(1); + } + if (value == Argon2Variant.ARGON2I) { + buf.write_i32(2); + } + if (value == Argon2Variant.ARGON2ID) { + buf.write_i32(3); + } + } +} + + + + + + +// Enumtemplate: 1 +enum Argon2Version { + _, + VERSION10, + VERSION13, + +} + + +// Generated By: EnumTemplate: 3 +class _UniffiConverterTypeArgon2Version extends _UniffiConverterRustBuffer { + read(_UniffiRustBufferBuilder buf) { + var variant = buf.read_i32(); + if (variant == 1) { + return Argon2Version.VERSION10; + } + if (variant == 2) { + return Argon2Version.VERSION13; + } + throw "Raw enum value doesn't match any cases"; + } + + write(_UniffiRustBufferBuilder buf, Argon2Version value) { + if (value == Argon2Version.VERSION10) { + buf.write_i32(1); + } + if (value == Argon2Version.VERSION13) { + buf.write_i32(2); + } + } +} + + + + + + +// Enumtemplate: 1 +enum CiphertextVersion { + _, + LATEST, + V1, + V2, + +} + + +// Generated By: EnumTemplate: 3 +class _UniffiConverterTypeCiphertextVersion extends _UniffiConverterRustBuffer { + read(_UniffiRustBufferBuilder buf) { + var variant = buf.read_i32(); + if (variant == 1) { + return CiphertextVersion.LATEST; + } + if (variant == 2) { + return CiphertextVersion.V1; + } + if (variant == 3) { + return CiphertextVersion.V2; + } + throw "Raw enum value doesn't match any cases"; + } + + write(_UniffiRustBufferBuilder buf, CiphertextVersion value) { + if (value == CiphertextVersion.LATEST) { + buf.write_i32(1); + } + if (value == CiphertextVersion.V1) { + buf.write_i32(2); + } + if (value == CiphertextVersion.V2) { + buf.write_i32(3); + } + } +} + + + + + + +// Enumtemplate: 1 +enum DataType { + _, + NONE, + KEY, + CIPHERTEXT, + PASSWORD_HASH, + SHARE, + SIGNING_KEY, + SIGNATURE, + ONLINE_CIPHERTEXT, + +} + + +// Generated By: EnumTemplate: 3 +class _UniffiConverterTypeDataType extends _UniffiConverterRustBuffer { + read(_UniffiRustBufferBuilder buf) { + var variant = buf.read_i32(); + if (variant == 1) { + return DataType.NONE; + } + if (variant == 2) { + return DataType.KEY; + } + if (variant == 3) { + return DataType.CIPHERTEXT; + } + if (variant == 4) { + return DataType.PASSWORD_HASH; + } + if (variant == 5) { + return DataType.SHARE; + } + if (variant == 6) { + return DataType.SIGNING_KEY; + } + if (variant == 7) { + return DataType.SIGNATURE; + } + if (variant == 8) { + return DataType.ONLINE_CIPHERTEXT; + } + throw "Raw enum value doesn't match any cases"; + } + + write(_UniffiRustBufferBuilder buf, DataType value) { + if (value == DataType.NONE) { + buf.write_i32(1); + } + if (value == DataType.KEY) { + buf.write_i32(2); + } + if (value == DataType.CIPHERTEXT) { + buf.write_i32(3); + } + if (value == DataType.PASSWORD_HASH) { + buf.write_i32(4); + } + if (value == DataType.SHARE) { + buf.write_i32(5); + } + if (value == DataType.SIGNING_KEY) { + buf.write_i32(6); + } + if (value == DataType.SIGNATURE) { + buf.write_i32(7); + } + if (value == DataType.ONLINE_CIPHERTEXT) { + buf.write_i32(8); + } + } +} + + + +//# DevolutionsCryptoError +//# We want to define each variant as a nested class that's also a subclass, +//# which is tricky in Python. To accomplish this we're going to create each +//# class separately, then manually add the child classes to the base class's +//# __dict__. All of this happens in dummy class to avoid polluting the module +//# namespace. + +// Generated by ErrorTemplate: 1 +class DevolutionsCryptoErrorException implements Exception { + String cause; + DevolutionsCryptoErrorException(this.cause); +} + +//_UniffiTempDevolutionsCryptoError = DevolutionsCryptoError + +// Generated by ErrorTemplate: 2 +class DevolutionsCryptoError implements Exception{ + final String cause; + + DevolutionsCryptoError(this.cause); + DevolutionsCryptoError.InvalidLength(this.cause); + //_UniffiTempDevolutionsCryptoError.InvalidLength = InvalidLength + DevolutionsCryptoError.InvalidKeyLength(this.cause); + //_UniffiTempDevolutionsCryptoError.InvalidKeyLength = InvalidKeyLength + DevolutionsCryptoError.InvalidOutputLength(this.cause); + //_UniffiTempDevolutionsCryptoError.InvalidOutputLength = InvalidOutputLength + DevolutionsCryptoError.InvalidSignature(this.cause); + //_UniffiTempDevolutionsCryptoError.InvalidSignature = InvalidSignature + DevolutionsCryptoError.InvalidMac(this.cause); + //_UniffiTempDevolutionsCryptoError.InvalidMac = InvalidMac + DevolutionsCryptoError.InvalidDataType(this.cause); + //_UniffiTempDevolutionsCryptoError.InvalidDataType = InvalidDataType + DevolutionsCryptoError.UnknownType(this.cause); + //_UniffiTempDevolutionsCryptoError.UnknownType = UnknownType + DevolutionsCryptoError.UnknownSubtype(this.cause); + //_UniffiTempDevolutionsCryptoError.UnknownSubtype = UnknownSubtype + DevolutionsCryptoError.UnknownVersion(this.cause); + //_UniffiTempDevolutionsCryptoError.UnknownVersion = UnknownVersion + DevolutionsCryptoError.InvalidData(this.cause); + //_UniffiTempDevolutionsCryptoError.InvalidData = InvalidData + DevolutionsCryptoError.NullPointer(this.cause); + //_UniffiTempDevolutionsCryptoError.NullPointer = NullPointer + DevolutionsCryptoError.CryptoError(this.cause); + //_UniffiTempDevolutionsCryptoError.CryptoError = CryptoError + DevolutionsCryptoError.RandomError(this.cause); + //_UniffiTempDevolutionsCryptoError.RandomError = RandomError + DevolutionsCryptoError.IoError(this.cause); + //_UniffiTempDevolutionsCryptoError.IoError = IoError + DevolutionsCryptoError.NotEnoughShares(this.cause); + //_UniffiTempDevolutionsCryptoError.NotEnoughShares = NotEnoughShares + DevolutionsCryptoError.InconsistentVersion(this.cause); + //_UniffiTempDevolutionsCryptoError.InconsistentVersion = InconsistentVersion + DevolutionsCryptoError.InvalidChunkLength(this.cause); + //_UniffiTempDevolutionsCryptoError.InvalidChunkLength = InvalidChunkLength + DevolutionsCryptoError.PoisonedMutex(this.cause); + //_UniffiTempDevolutionsCryptoError.PoisonedMutex = PoisonedMutex +} + +//DevolutionsCryptoError = _UniffiTempDevolutionsCryptoError +//del _UniffiTempDevolutionsCryptoError + +// Generated by ErrorTemplate: 3 +class _UniffiConverterTypeDevolutionsCryptoError extends _UniffiWithError { + _UniffiRustBuffer lift(Pointer<_UniffiRustCallStatus> val) { + //print(val.ref.error_buf.toDartString()); + return val.ref.error_buf; + + } + + @override + liftNotStatic(Pointer<_UniffiRustCallStatus> buf) { + return lift(buf); + } + + toError(Pointer<_UniffiRustCallStatus> val) { + print("Debug (${val.ref.code}): '${val.ref.error_buf.data.toDartString()}'"); + if (val.ref.code == 1) { + throw DevolutionsCryptoError.InvalidLength( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 2) { + throw DevolutionsCryptoError.InvalidKeyLength( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 3) { + throw DevolutionsCryptoError.InvalidOutputLength( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 4) { + throw DevolutionsCryptoError.InvalidSignature( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 5) { + throw DevolutionsCryptoError.InvalidMac( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 6) { + throw DevolutionsCryptoError.InvalidDataType( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 7) { + throw DevolutionsCryptoError.UnknownType( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 8) { + throw DevolutionsCryptoError.UnknownSubtype( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 9) { + throw DevolutionsCryptoError.UnknownVersion( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 10) { + throw DevolutionsCryptoError.InvalidData( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 11) { + throw DevolutionsCryptoError.NullPointer( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 12) { + throw DevolutionsCryptoError.CryptoError( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 13) { + throw DevolutionsCryptoError.RandomError( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 14) { + throw DevolutionsCryptoError.IoError( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 15) { + throw DevolutionsCryptoError.NotEnoughShares( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 16) { + throw DevolutionsCryptoError.InconsistentVersion( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 17) { + throw DevolutionsCryptoError.InvalidChunkLength( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + if (val.ref.code == 18) { + throw DevolutionsCryptoError.PoisonedMutex( + _UniffiConverterString().lift(val.ref.error_buf) + ); + } + throw "Does not match any cases (${val.ref.code}): ${val.ref.error_buf.data.toDartString()}"; + } + + read(buf) { + //variant = buf.read_i32() + // + //if variant == 1: + // return DevolutionsCryptoError.InvalidLength( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 2: + // return DevolutionsCryptoError.InvalidKeyLength( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 3: + // return DevolutionsCryptoError.InvalidOutputLength( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 4: + // return DevolutionsCryptoError.InvalidSignature( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 5: + // return DevolutionsCryptoError.InvalidMac( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 6: + // return DevolutionsCryptoError.InvalidDataType( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 7: + // return DevolutionsCryptoError.UnknownType( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 8: + // return DevolutionsCryptoError.UnknownSubtype( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 9: + // return DevolutionsCryptoError.UnknownVersion( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 10: + // return DevolutionsCryptoError.InvalidData( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 11: + // return DevolutionsCryptoError.NullPointer( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 12: + // return DevolutionsCryptoError.CryptoError( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 13: + // return DevolutionsCryptoError.RandomError( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 14: + // return DevolutionsCryptoError.IoError( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 15: + // return DevolutionsCryptoError.NotEnoughShares( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 16: + // return DevolutionsCryptoError.InconsistentVersion( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 17: + // return DevolutionsCryptoError.InvalidChunkLength( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //if variant == 18: + // return DevolutionsCryptoError.PoisonedMutex( + // + // _UniffiConverterString().read(buf), + // + // ) + // + //raise InternalError("Raw enum value doesn't match any cases") + } + + static write(value, buf) { + // + //if isinstance(value, DevolutionsCryptoError.InvalidLength): + // buf.write_i32(1) + // + // + //if isinstance(value, DevolutionsCryptoError.InvalidKeyLength): + // buf.write_i32(2) + // + // + //if isinstance(value, DevolutionsCryptoError.InvalidOutputLength): + // buf.write_i32(3) + // + // + //if isinstance(value, DevolutionsCryptoError.InvalidSignature): + // buf.write_i32(4) + // + // + //if isinstance(value, DevolutionsCryptoError.InvalidMac): + // buf.write_i32(5) + // + // + //if isinstance(value, DevolutionsCryptoError.InvalidDataType): + // buf.write_i32(6) + // + // + //if isinstance(value, DevolutionsCryptoError.UnknownType): + // buf.write_i32(7) + // + // + //if isinstance(value, DevolutionsCryptoError.UnknownSubtype): + // buf.write_i32(8) + // + // + //if isinstance(value, DevolutionsCryptoError.UnknownVersion): + // buf.write_i32(9) + // + // + //if isinstance(value, DevolutionsCryptoError.InvalidData): + // buf.write_i32(10) + // + // + //if isinstance(value, DevolutionsCryptoError.NullPointer): + // buf.write_i32(11) + // + // + //if isinstance(value, DevolutionsCryptoError.CryptoError): + // buf.write_i32(12) + // + // + //if isinstance(value, DevolutionsCryptoError.RandomError): + // buf.write_i32(13) + // + // + //if isinstance(value, DevolutionsCryptoError.IoError): + // buf.write_i32(14) + // + // + //if isinstance(value, DevolutionsCryptoError.NotEnoughShares): + // buf.write_i32(15) + // + // + //if isinstance(value, DevolutionsCryptoError.InconsistentVersion): + // buf.write_i32(16) + // + // + //if isinstance(value, DevolutionsCryptoError.InvalidChunkLength): + // buf.write_i32(17) + // + // + //if isinstance(value, DevolutionsCryptoError.PoisonedMutex): + // buf.write_i32(18) + // + // + } +} + + + + + +// Enumtemplate: 1 +enum KeyVersion { + _, + LATEST, + V1, + +} + + +// Generated By: EnumTemplate: 3 +class _UniffiConverterTypeKeyVersion extends _UniffiConverterRustBuffer { + read(_UniffiRustBufferBuilder buf) { + var variant = buf.read_i32(); + if (variant == 1) { + return KeyVersion.LATEST; + } + if (variant == 2) { + return KeyVersion.V1; + } + throw "Raw enum value doesn't match any cases"; + } + + write(_UniffiRustBufferBuilder buf, KeyVersion value) { + if (value == KeyVersion.LATEST) { + buf.write_i32(1); + } + if (value == KeyVersion.V1) { + buf.write_i32(2); + } + } +} + + + + + + +// Enumtemplate: 1 +enum PasswordHashVersion { + _, + LATEST, + V1, + +} + + +// Generated By: EnumTemplate: 3 +class _UniffiConverterTypePasswordHashVersion extends _UniffiConverterRustBuffer { + read(_UniffiRustBufferBuilder buf) { + var variant = buf.read_i32(); + if (variant == 1) { + return PasswordHashVersion.LATEST; + } + if (variant == 2) { + return PasswordHashVersion.V1; + } + throw "Raw enum value doesn't match any cases"; + } + + write(_UniffiRustBufferBuilder buf, PasswordHashVersion value) { + if (value == PasswordHashVersion.LATEST) { + buf.write_i32(1); + } + if (value == PasswordHashVersion.V1) { + buf.write_i32(2); + } + } +} + + + + + + +// Enumtemplate: 1 +enum SecretSharingVersion { + _, + LATEST, + V1, + +} + + +// Generated By: EnumTemplate: 3 +class _UniffiConverterTypeSecretSharingVersion extends _UniffiConverterRustBuffer { + read(_UniffiRustBufferBuilder buf) { + var variant = buf.read_i32(); + if (variant == 1) { + return SecretSharingVersion.LATEST; + } + if (variant == 2) { + return SecretSharingVersion.V1; + } + throw "Raw enum value doesn't match any cases"; + } + + write(_UniffiRustBufferBuilder buf, SecretSharingVersion value) { + if (value == SecretSharingVersion.LATEST) { + buf.write_i32(1); + } + if (value == SecretSharingVersion.V1) { + buf.write_i32(2); + } + } +} + + + + + + +// Enumtemplate: 1 +enum SignatureVersion { + _, + LATEST, + V1, + +} + + +// Generated By: EnumTemplate: 3 +class _UniffiConverterTypeSignatureVersion extends _UniffiConverterRustBuffer { + read(_UniffiRustBufferBuilder buf) { + var variant = buf.read_i32(); + if (variant == 1) { + return SignatureVersion.LATEST; + } + if (variant == 2) { + return SignatureVersion.V1; + } + throw "Raw enum value doesn't match any cases"; + } + + write(_UniffiRustBufferBuilder buf, SignatureVersion value) { + if (value == SignatureVersion.LATEST) { + buf.write_i32(1); + } + if (value == SignatureVersion.V1) { + buf.write_i32(2); + } + } +} + + + + + + +// Enumtemplate: 1 +enum SigningKeyVersion { + _, + LATEST, + V1, + +} + + +// Generated By: EnumTemplate: 3 +class _UniffiConverterTypeSigningKeyVersion extends _UniffiConverterRustBuffer { + read(_UniffiRustBufferBuilder buf) { + var variant = buf.read_i32(); + if (variant == 1) { + return SigningKeyVersion.LATEST; + } + if (variant == 2) { + return SigningKeyVersion.V1; + } + throw "Raw enum value doesn't match any cases"; + } + + write(_UniffiRustBufferBuilder buf, SigningKeyVersion value) { + if (value == SigningKeyVersion.LATEST) { + buf.write_i32(1); + } + if (value == SigningKeyVersion.V1) { + buf.write_i32(2); + } + } +} + + + + +// Generated by OptionalTemplate +class _UniffiConverterOptionalBytes extends _UniffiConverterRustBuffer?> { + + write(_UniffiRustBufferBuilder buf, value) { + if(value == null) { + buf.write_u8(0); + return buf; + } + buf.write_u8(1); + //_UniffiConverterBytes.write(value, buf) + } + + read(_UniffiRustBufferBuilder buf) { + var flag = buf.read_u8(); + if(flag == 0) { + return null; + } else if (flag == 1) { + return _UniffiConverterBytes().read(buf); + } else { + throw "Unexpected flag byte for optional type"; + } + } + + + //// U8 - is the storage + //@override + //List? lift(_UniffiRustBuffer buf) { + // if (buf.len > 0) { + // buf.data = Pointer.fromAddress(buf.data.address + 0x5); + // return _UniffiConverterBytes().lift(buf); + // } else { + // return null; + // } + //} + + //@override + //_UniffiRustBuffer lower(buf) { + // if (buf == null) { + // return _UniffiConverterBytes.write("\u{0}"); + // } else { + // return _UniffiConverterBytes.write("\u{1}" + buf); + // } + //} +} + + + +// Generated by SequenceTemplate +class _UniffiConverterSequenceBytes extends _UniffiConverterRustBuffer>> { + + read(_UniffiRustBufferBuilder buf) { + var count = buf.read_i32(); + if (count < 0) { + throw "Unexpected negative sequence length"; + } + + List> list = []; + + for (var i = 0; i < count; i++) { + var item = _UniffiConverterBytes().read(buf); + list.add(item); + } + + return list; + } + + write(_UniffiRustBufferBuilder buf, value) { + //buf.data.cast = value; + Pointer<_UniffiRustBuffer> _rustBuffer = calloc<_UniffiRustBuffer >(); + return _rustBuffer.ref.buffer; + } +} + +// From TopLevelFunctionTemplate: 2 +List encrypt(List data,List key,CiphertextVersion version) { + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterBytes().lower(key), + _UniffiConverterTypeCiphertextVersion().lower(version), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List encrypt_asymmetric(List data,List key,CiphertextVersion version) { + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterBytes().lower(key), + _UniffiConverterTypeCiphertextVersion().lower(version), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List encrypt_asymmetric_with_aad(List data,List key,List aad,CiphertextVersion version) { + + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_asymmetric_with_aad_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterBytes().lower(key), + _UniffiConverterBytes().lower(aad), + _UniffiConverterTypeCiphertextVersion().lower(version), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List encrypt_with_aad(List data,List key,List aad,CiphertextVersion version) { + + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_encrypt_with_aad_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterBytes().lower(key), + _UniffiConverterBytes().lower(aad), + _UniffiConverterTypeCiphertextVersion().lower(version), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +KeyPair generate_keypair(KeyVersion version) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeKeyPair().lift(_rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_keypair_func( + _UniffiConverterTypeKeyVersion().lower(version), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List> generate_shared_key(int n_shares,int threshold,int length,SecretSharingVersion version) { + + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterSequenceBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_shared_key_func( + _UniffiConverterUInt8().lower(n_shares), + _UniffiConverterUInt8().lower(threshold), + _UniffiConverterUInt32().lower(length), + _UniffiConverterTypeSecretSharingVersion().lower(version), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +SigningKeyPair generate_signing_keypair(SigningKeyVersion version) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterTypeSigningKeyPair().lift(_rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_signing_keypair_func( + _UniffiConverterTypeSigningKeyVersion().lower(version), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List hash_password(List password,int iterations,PasswordHashVersion version) { + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_hash_password_func( + _UniffiConverterBytes().lower(password), + _UniffiConverterUInt32().lower(iterations), + _UniffiConverterTypePasswordHashVersion().lower(version), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List sign(List data,List keypair,SignatureVersion version) { + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_sign_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterBytes().lower(keypair), + _UniffiConverterTypeSignatureVersion().lower(version), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List base64_decode(String data) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_func( + _UniffiConverterString().lower(data), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List base64_decode_url(String data) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_decode_url_func( + _UniffiConverterString().lower(data), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +String base64_encode(List data) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterString().lift(_rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_func( + _UniffiConverterBytes().lower(data), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +String base64_encode_url(List data) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterString().lift(_rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_base64_encode_url_func( + _UniffiConverterBytes().lower(data), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List decrypt(List data,List key) { + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterBytes().lower(key), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List decrypt_asymmetric(List data,List key) { + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterBytes().lower(key), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List decrypt_asymmetric_with_aad(List data,List key,List aad) { + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_asymmetric_with_aad_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterBytes().lower(key), + _UniffiConverterBytes().lower(aad), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List decrypt_with_aad(List data,List key,List aad) { + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_decrypt_with_aad_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterBytes().lower(key), + _UniffiConverterBytes().lower(aad), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List derive_key_argon2(List key,Argon2Parameters parameters) { + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_argon2_func( + _UniffiConverterBytes().lower(key), + _UniffiConverterTypeArgon2Parameters().lower(parameters), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List derive_key_pbkdf2(List key,List? salt,int iterations,int length) { + + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_derive_key_pbkdf2_func( + _UniffiConverterBytes().lower(key), + _UniffiConverterOptionalBytes().lower(salt), + _UniffiConverterUInt32().lower(iterations), + _UniffiConverterUInt32().lower(length), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List generate_key(int length) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_generate_key_func( + _UniffiConverterUInt32().lower(length), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List join_shares(List> shares) { + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_join_shares_func( + _UniffiConverterSequenceBytes().lower(shares), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +List mix_key_exchange(List private_key,List public_key) { + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBytes().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_mix_key_exchange_func( + _UniffiConverterBytes().lower(private_key), + _UniffiConverterBytes().lower(public_key), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +bool validate_header(List data,DataType data_type) { + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBool().lift(_rustCall(() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_validate_header_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterTypeDataType().lower(data_type), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +bool verify_password(List password,List hash) { + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBool().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_password_func( + _UniffiConverterBytes().lower(password), + _UniffiConverterBytes().lower(hash), + _rustCallStatus), + _rustCallStatus +)); +} + + + +// From TopLevelFunctionTemplate: 2 +bool verify_signature(List data,List public_key,List signature) { + + + +final Pointer<_UniffiRustCallStatus> _rustCallStatus = calloc<_UniffiRustCallStatus >(); + return _UniffiConverterBool().lift(_rustCallWithError(_UniffiConverterTypeDevolutionsCryptoError(),() => _UniffiLib_uniffi_devolutions_crypto_uniffi_dart_fn_func_verify_signature_func( + _UniffiConverterBytes().lower(data), + _UniffiConverterBytes().lower(public_key), + _UniffiConverterBytes().lower(signature), + _rustCallStatus), + _rustCallStatus +)); +} + + + diff --git a/wrappers/dart/devolutions_crypto_dart/libuniffi_devolutions_crypto.dll b/wrappers/dart/devolutions_crypto_dart/libuniffi_devolutions_crypto.dll new file mode 100644 index 000000000..aad4a29e3 Binary files /dev/null and b/wrappers/dart/devolutions_crypto_dart/libuniffi_devolutions_crypto.dll differ diff --git a/wrappers/dart/devolutions_crypto_dart/pubspec.yaml b/wrappers/dart/devolutions_crypto_dart/pubspec.yaml new file mode 100644 index 000000000..2bc41df07 --- /dev/null +++ b/wrappers/dart/devolutions_crypto_dart/pubspec.yaml @@ -0,0 +1,17 @@ +name: devolutions_crypto_dart +description: A starting point for Dart libraries or applications. +version: 1.0.0 +# repository: https://github.com/my_org/my_repo + +environment: + sdk: ^3.7.2 + +# Add regular dependencies here. +dependencies: + # path: ^1.8.0 + ffi: ^2.1.4 + mutex: ^3.1.0 + +dev_dependencies: + lints: ^5.0.0 + test: ^1.24.0 diff --git a/wrappers/dart/devolutions_crypto_dart/test/devolutions_crypto_dart_test.dart b/wrappers/dart/devolutions_crypto_dart/test/devolutions_crypto_dart_test.dart new file mode 100644 index 000000000..fc3eb2692 --- /dev/null +++ b/wrappers/dart/devolutions_crypto_dart/test/devolutions_crypto_dart_test.dart @@ -0,0 +1,17 @@ +import 'package:devolutions_crypto_dart/devolutions_crypto.dart'; +import 'package:test/test.dart'; + +void main() { + group('A group of tests', () { + final awesome = generate_key(32); + print(awesome); + print("BABABABAB"); + setUp(() { + // Additional setup goes here. + }); + + test('First Test', () { + expect(awesome.length == 32, isTrue); + }); + }); +} diff --git a/wrappers/dart/generate.sh b/wrappers/dart/generate.sh new file mode 100644 index 000000000..af26460ff --- /dev/null +++ b/wrappers/dart/generate.sh @@ -0,0 +1,2 @@ +cargo build -p devolutions-crypto-uniffi-dart +cargo run -p uniffi-dart-bindgen generate ..\..\uniffi\devolutions-crypto-uniffi-dart\src\devolutions_crypto.udl --lib-file ..\..\target\debug\devolutions_crypto_uniffi_dart.dll --language dart --out-dir bindings --no-format \ No newline at end of file