export api types to ts (#2583)

core/startos/src/action.rs

@@ -4,6 +4,7 @@ use models::PackageId;
 use rpc_toolkit::command;
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::config::Config;
 use crate::context::RpcContext;
@@ -47,17 +48,17 @@ pub fn display_action_result(params: WithIoFormat<ActionParams>, result: ActionR
     }
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ActionParams {
     #[arg(id = "id")]
     #[serde(rename = "id")]
     pub package_id: PackageId,
-    #[arg(id = "action-id")]
-    #[serde(rename = "action-id")]
     pub action_id: ActionId,
     #[command(flatten)]
+    #[ts(type = "{ [key: string]: any } | null")]
     pub input: StdinDeserializable<Option<Config>>,
 }
 // impl C

core/startos/src/auth.rs

@@ -9,6 +9,7 @@ use rpc_toolkit::yajrc::RpcError;
 use rpc_toolkit::{command, from_fn_async, AnyContext, CallRemote, HandlerExt, ParentHandler};
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::db::model::DatabaseModel;
@@ -20,7 +21,8 @@ use crate::util::crypto::EncryptedWire;
 use crate::util::serde::{display_serializable, HandlerExtSerde, WithIoFormat};
 use crate::{ensure_code, Error, ResultExt};
 
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize, TS)]
+#[ts(as = "BTreeMap::<String, Session>")]
 pub struct Sessions(pub BTreeMap<InternedString, Session>);
 impl Sessions {
     pub fn new() -> Self {
@@ -38,8 +40,9 @@ impl Map for Sessions {
     }
 }
 
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Serialize, Deserialize, TS)]
 #[serde(untagged)]
+#[ts(export)]
 pub enum PasswordType {
     EncryptedWire(EncryptedWire),
     String(String),
@@ -177,14 +180,16 @@ pub fn check_password_against_db(db: &DatabaseModel, password: &str) -> Result<(
     Ok(())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct LoginParams {
     password: Option<PasswordType>,
     #[serde(default)]
     user_agent: Option<String>,
     #[serde(default)]
+    #[ts(type = "any")]
     metadata: Value,
 }
 
@@ -218,10 +223,12 @@ pub async fn login_impl(
         .await
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct LogoutParams {
+    #[ts(type = "string")]
     session: InternedString,
 }
 
@@ -234,18 +241,25 @@ pub async fn logout(
     ))
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
+#[ts(export)]
 pub struct Session {
+    #[ts(type = "string")]
     pub logged_in: DateTime<Utc>,
+    #[ts(type = "string")]
     pub last_active: DateTime<Utc>,
+    #[ts(skip)]
     pub user_agent: Option<String>,
+    #[ts(type = "any")]
     pub metadata: Value,
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
+#[ts(export)]
 pub struct SessionList {
+    #[ts(type = "string")]
     current: InternedString,
     sessions: Sessions,
 }
@@ -303,11 +317,13 @@ fn display_sessions(params: WithIoFormat<ListParams>, arg: SessionList) {
     table.print_tty(false).unwrap();
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ListParams {
     #[arg(skip)]
+    #[ts(skip)]
     session: InternedString,
 }
 
@@ -338,9 +354,10 @@ impl AsLogoutSessionId for KillSessionId {
     }
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct KillParams {
     ids: Vec<String>,
 }
@@ -351,9 +368,10 @@ pub async fn kill(ctx: RpcContext, KillParams { ids }: KillParams) -> Result<(),
     Ok(())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ResetPasswordParams {
     old_password: Option<PasswordType>,
     new_password: Option<PasswordType>,

core/startos/src/backup/backup_bulk.rs

@@ -11,6 +11,7 @@ use models::PackageId;
 use serde::{Deserialize, Serialize};
 use tokio::io::AsyncWriteExt;
 use tracing::instrument;
+use ts_rs::TS;
 
 use super::target::BackupTargetId;
 use super::PackageBackupReport;
@@ -29,9 +30,10 @@ use crate::util::io::dir_copy;
 use crate::util::serde::IoFormat;
 use crate::version::VersionT;
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct BackupParams {
     target_id: BackupTargetId,
     #[arg(long = "old-password")]

core/startos/src/backup/restore.rs

@@ -9,6 +9,7 @@ use patch_db::json_ptr::ROOT;
 use serde::{Deserialize, Serialize};
 use torut::onion::OnionAddressV3;
 use tracing::instrument;
+use ts_rs::TS;
 
 use super::target::BackupTargetId;
 use crate::backup::os::OsBackup;
@@ -24,9 +25,10 @@ use crate::s9pk::S9pk;
 use crate::service::service_map::DownloadInstallFuture;
 use crate::util::serde::IoFormat;
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct RestorePackageParams {
     pub ids: Vec<PackageId>,
     pub target_id: BackupTargetId,

core/startos/src/backup/target/cifs.rs

@@ -6,6 +6,7 @@ use color_eyre::eyre::eyre;
 use imbl_value::InternedString;
 use rpc_toolkit::{command, from_fn_async, HandlerExt, ParentHandler};
 use serde::{Deserialize, Serialize};
+use ts_rs::TS;
 
 use super::{BackupTarget, BackupTargetId};
 use crate::context::{CliContext, RpcContext};
@@ -67,9 +68,10 @@ pub fn cifs() -> ParentHandler {
         )
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct AddParams {
     pub hostname: String,
     pub path: PathBuf,
@@ -121,9 +123,10 @@ pub async fn add(
     })
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct UpdateParams {
     pub id: BackupTargetId,
     pub hostname: String,
@@ -185,9 +188,10 @@ pub async fn update(
     })
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct RemoveParams {
     pub id: BackupTargetId,
 }

core/startos/src/backup/target/mod.rs

@@ -13,6 +13,7 @@ use serde::{Deserialize, Serialize};
 use sha2::Sha256;
 use tokio::sync::Mutex;
 use tracing::instrument;
+use ts_rs::TS;
 
 use self::cifs::CifsBackupTarget;
 use crate::context::{CliContext, RpcContext};
@@ -46,7 +47,8 @@ pub enum BackupTarget {
     Cifs(CifsBackupTarget),
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, TS)]
+#[ts(type = "string")]
 pub enum BackupTargetId {
     Disk { logicalname: PathBuf },
     Cifs { id: u32 },
@@ -107,7 +109,7 @@ impl Serialize for BackupTargetId {
     }
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, TS)]
 #[serde(tag = "type")]
 #[serde(rename_all = "camelCase")]
 pub enum BackupTargetFS {
@@ -242,9 +244,10 @@ fn display_backup_info(params: WithIoFormat<InfoParams>, info: BackupInfo) {
     table.print_tty(false).unwrap();
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct InfoParams {
     target_id: BackupTargetId,
     password: String,
@@ -276,9 +279,10 @@ lazy_static::lazy_static! {
         Mutex::new(BTreeMap::new());
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct MountParams {
     target_id: BackupTargetId,
     password: String,
@@ -311,9 +315,10 @@ pub async fn mount(
     Ok(res)
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct UmountParams {
     target_id: Option<BackupTargetId>,
 }

core/startos/src/config/mod.rs

@@ -12,6 +12,7 @@ use regex::Regex;
 use rpc_toolkit::{from_fn_async, Empty, HandlerExt, ParentHandler};
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::prelude::*;
@@ -125,9 +126,10 @@ pub enum MatchError {
     ListUniquenessViolation,
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ConfigParams {
     pub id: PackageId,
 }
@@ -156,12 +158,14 @@ pub async fn get(ctx: RpcContext, _: Empty, id: PackageId) -> Result<ConfigRes,
         .await
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
+#[ts(export)]
 pub struct SetParams {
     #[arg(long = "timeout")]
     pub timeout: Option<crate::util::serde::Duration>,
     #[command(flatten)]
+    #[ts(type = "{ [key: string]: any } | null")]
     pub config: StdinDeserializable<Option<Config>>,
 }
 

core/startos/src/control.rs

@@ -4,14 +4,16 @@ use models::PackageId;
 use rpc_toolkit::command;
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::context::RpcContext;
 use crate::prelude::*;
 use crate::Error;
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ControlParams {
     pub id: PackageId,
 }

core/startos/src/db/mod.rs

@@ -19,6 +19,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use tokio::sync::oneshot;
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::middleware::auth::{HasValidSession, HashSessionToken};
@@ -215,12 +216,14 @@ async fn cli_dump(
     Ok(dump)
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct DumpParams {
     #[arg(long = "include-private", short = 'p')]
     #[serde(default)]
+    #[ts(skip)]
     include_private: bool,
 }
 
@@ -271,9 +274,10 @@ async fn cli_apply(
     Ok(())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ApplyParams {
     expr: String,
     path: Option<PathBuf>,
@@ -309,11 +313,14 @@ pub fn put() -> ParentHandler {
             .with_remote_cli::<CliContext>(),
     )
 }
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct UiParams {
+    #[ts(type = "string")]
     pointer: JsonPointer,
+    #[ts(type = "any")]
     value: Value,
 }
 

core/startos/src/dependencies.rs

@@ -43,9 +43,10 @@ pub struct DepInfo {
     pub optional: bool,
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ConfigureParams {
     dependent_id: PackageId,
     dependency_id: PackageId,

core/startos/src/diagnostic.rs

@@ -5,6 +5,7 @@ use clap::Parser;
 use rpc_toolkit::yajrc::RpcError;
 use rpc_toolkit::{command, from_fn, from_fn_async, AnyContext, HandlerExt, ParentHandler};
 use serde::{Deserialize, Serialize};
+use ts_rs::TS;
 
 use crate::context::{CliContext, DiagnosticContext};
 use crate::init::SYSTEM_REBUILD_PATH;
@@ -40,10 +41,12 @@ pub fn error(ctx: DiagnosticContext) -> Result<Arc<RpcError>, Error> {
     Ok(ctx.error.clone())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct LogsParams {
+    #[ts(type = "number | null")]
     limit: Option<usize>,
     cursor: Option<String>,
     before: bool,

core/startos/src/disk/mount/filesystem/block_dev.rs

@@ -5,12 +5,14 @@ use digest::generic_array::GenericArray;
 use digest::{Digest, OutputSizeUser};
 use serde::{Deserialize, Serialize};
 use sha2::Sha256;
+use ts_rs::TS;
 
 use super::FileSystem;
 use crate::prelude::*;
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
+#[ts(concrete(LogicalName = std::path::PathBuf))]
 pub struct BlockDev<LogicalName: AsRef<Path>> {
     logicalname: LogicalName,
 }

core/startos/src/disk/mount/filesystem/cifs.rs

@@ -8,6 +8,7 @@ use serde::{Deserialize, Serialize};
 use sha2::Sha256;
 use tokio::process::Command;
 use tracing::instrument;
+use ts_rs::TS;
 
 use super::{FileSystem, MountType, ReadOnly};
 use crate::disk::mount::guard::{GenericMountGuard, TmpMountGuard};
@@ -62,7 +63,7 @@ pub async fn mount_cifs(
     Ok(())
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 pub struct Cifs {
     pub hostname: String,

core/startos/src/inspect.rs

@@ -23,9 +23,10 @@ pub fn inspect() -> ParentHandler {
         .subcommand("docker-images", from_fn_async(docker_images).no_display())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct HashParams {
     path: PathBuf,
 }
@@ -38,9 +39,10 @@ pub async fn hash(_: CliContext, HashParams { path }: HashParams) -> Result<Stri
         .to_owned())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ManifestParams {
     path: PathBuf,
     #[arg(long = "no-verify")]
@@ -56,9 +58,10 @@ pub async fn manifest(
     todo!()
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct InspectParams {
     path: PathBuf,
     #[arg(long = "no-verify")]
@@ -88,9 +91,10 @@ pub async fn icon(
     .await?;
     Ok(())
 }
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct InstructionParams {
     path: PathBuf,
     #[arg(long = "no-verify")]

core/startos/src/install/mod.rs

@@ -15,6 +15,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use tokio::sync::oneshot;
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::core::rpc_continuations::{RequestGuid, RpcContinuation};
@@ -63,7 +64,7 @@ pub async fn list(ctx: RpcContext) -> Result<Value, Error> {
         .collect())
 }
 
-#[derive(Debug, Clone, Copy, serde::Deserialize, serde::Serialize)]
+#[derive(Debug, Clone, Copy, serde::Deserialize, serde::Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 pub enum MinMax {
     Min,
@@ -102,12 +103,14 @@ impl std::fmt::Display for MinMax {
     }
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct InstallParams {
     id: PackageId,
     #[arg(short = 'm', long = "marketplace-url")]
+    #[ts(type = "string | null")]
     marketplace_url: Option<Url>,
     #[arg(short = 'v', long = "version-spec")]
     version_spec: Option<String>,
@@ -391,9 +394,10 @@ pub async fn cli_install(ctx: CliContext, params: CliInstallParams) -> Result<()
     Ok(())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct UninstallParams {
     id: PackageId,
 }

core/startos/src/lib.rs

@@ -75,13 +75,15 @@ use rpc_toolkit::{
     command, from_fn, from_fn_async, from_fn_blocking, AnyContext, HandlerExt, ParentHandler,
 };
 use serde::{Deserialize, Serialize};
+use ts_rs::TS;
 
 use crate::context::CliContext;
 use crate::util::serde::HandlerExtSerde;
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct EchoParams {
     message: String,
 }

core/startos/src/lxc/mod.rs

@@ -20,6 +20,7 @@ use tokio::io::{AsyncBufReadExt, BufReader};
 use tokio::process::Command;
 use tokio::sync::Mutex;
 use tokio::time::Instant;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::core::rpc_continuations::{RequestGuid, RpcContinuation};
@@ -351,8 +352,10 @@ pub async fn list(ctx: RpcContext) -> Result<Vec<InternedString>, Error> {
     Ok(ctx.dev.lxc.lock().await.keys().cloned().collect())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
+#[ts(export)]
 pub struct RemoveParams {
+    #[ts(type = "string")]
     pub guid: InternedString,
 }
 
@@ -363,8 +366,10 @@ pub async fn remove(ctx: RpcContext, RemoveParams { guid }: RemoveParams) -> Res
     Ok(())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
+#[ts(export)]
 pub struct ConnectParams {
+    #[ts(type = "string")]
     pub guid: InternedString,
 }
 

core/startos/src/net/dhcp.rs

@@ -6,6 +6,7 @@ use futures::TryStreamExt;
 use rpc_toolkit::{from_fn_async, HandlerExt, ParentHandler};
 use serde::{Deserialize, Serialize};
 use tokio::sync::RwLock;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::db::model::public::IpInfo;
@@ -60,9 +61,10 @@ pub fn dhcp() -> ParentHandler {
             .with_remote_cli::<CliContext>(),
     )
 }
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct UpdateParams {
     interface: String,
 }

core/startos/src/net/tor.rs

@@ -22,6 +22,7 @@ use tokio::time::Instant;
 use torut::control::{AsyncEvent, AuthenticatedConn, ConnError};
 use torut::onion::{OnionAddressV3, TorSecretKeyV3};
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::logs::{
@@ -104,9 +105,10 @@ pub fn tor() -> ParentHandler {
                 .with_remote_cli::<CliContext>(),
         )
 }
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ResetParams {
     #[arg(name = "wipe-state", short = 'w', long = "wipe-state")]
     wipe_state: bool,
@@ -142,11 +144,13 @@ pub async fn list_services(ctx: RpcContext, _: Empty) -> Result<Vec<OnionAddress
     ctx.net_controller.tor.list_services().await
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct LogsParams {
     #[arg(short = 'l', long = "limit")]
+    #[ts(type = "number | null")]
     limit: Option<usize>,
     #[arg(short = 'c', long = "cursor")]
     cursor: Option<String>,

core/startos/src/net/wifi.rs

@@ -13,6 +13,7 @@ use serde::{Deserialize, Serialize};
 use tokio::process::Command;
 use tokio::sync::RwLock;
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::prelude::*;
@@ -87,9 +88,10 @@ pub fn country() -> ParentHandler {
     )
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct AddParams {
     ssid: String,
     password: String,
@@ -138,9 +140,10 @@ pub async fn add(ctx: RpcContext, AddParams { ssid, password }: AddParams) -> Re
     }
     Ok(())
 }
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct SsidParams {
     ssid: String,
 }
@@ -402,11 +405,13 @@ pub async fn get_available(ctx: RpcContext, _: Empty) -> Result<Vec<WifiListOut>
     Ok(wifi_list)
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct SetCountryParams {
     #[arg(value_parser = CountryCodeParser)]
+    #[ts(type = "string")]
     country: CountryCode,
 }
 pub async fn set_country(

core/startos/src/notifications.rs

@@ -11,6 +11,7 @@ use models::PackageId;
 use rpc_toolkit::{command, from_fn_async, HandlerExt, ParentHandler};
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::backup::BackupReport;
 use crate::context::{CliContext, RpcContext};
@@ -48,11 +49,14 @@ pub fn notification() -> ParentHandler {
         )
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ListParams {
+    #[ts(type = "number | null")]
     before: Option<u32>,
+    #[ts(type = "number | null")]
     limit: Option<usize>,
 }
 // #[command(display(display_serializable))]
@@ -110,10 +114,12 @@ pub async fn list(
         .await
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct DeleteParams {
+    #[ts(type = "number")]
     id: u32,
 }
 
@@ -125,10 +131,12 @@ pub async fn delete(ctx: RpcContext, DeleteParams { id }: DeleteParams) -> Resul
         })
         .await
 }
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct DeleteBeforeParams {
+    #[ts(type = "number")]
     before: u32,
 }
 
@@ -148,9 +156,10 @@ pub async fn delete_before(
         .await
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct CreateParams {
     package: Option<PackageId>,
     level: NotificationLevel,
@@ -172,7 +181,7 @@ pub async fn create(
         .await
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize, TS)]
 #[serde(rename_all = "camelCase")]
 pub enum NotificationLevel {
     Success,

core/startos/src/os_install/mod.rs

@@ -6,6 +6,7 @@ use models::Error;
 use rpc_toolkit::{command, from_fn_async, AnyContext, HandlerExt, ParentHandler};
 use serde::{Deserialize, Serialize};
 use tokio::process::Command;
+use ts_rs::TS;
 
 use crate::context::config::ServerConfig;
 use crate::context::{CliContext, InstallContext};
@@ -112,9 +113,10 @@ async fn partition(disk: &mut DiskInfo, overwrite: bool) -> Result<OsPartitionIn
     }
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ExecuteParams {
     logicalname: PathBuf,
     #[arg(short = 'o')]

core/startos/src/registry/admin.rs

@@ -9,6 +9,7 @@ use indicatif::{ProgressBar, ProgressStyle};
 use reqwest::{header, Body, Client, Url};
 use rpc_toolkit::command;
 use serde::{Deserialize, Serialize};
+use ts_rs::TS;
 
 use crate::context::CliContext;
 use crate::s9pk::S9pk;

core/startos/src/registry/marketplace.rs

@@ -5,6 +5,7 @@ use reqwest::{StatusCode, Url};
 use rpc_toolkit::{command, from_fn_async, HandlerExt, ParentHandler};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::version::VersionT;
@@ -36,10 +37,12 @@ pub fn with_query_params(ctx: RpcContext, mut url: Url) -> Url {
     url
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct GetParams {
+    #[ts(type = "string")]
     url: Url,
 }
 

core/startos/src/s9pk/rpc.rs

@@ -8,6 +8,7 @@ use rpc_toolkit::{from_fn_async, Empty, HandlerExt, ParentHandler};
 use serde::{Deserialize, Serialize};
 use tokio::fs::File;
 use tokio::process::Command;
+use ts_rs::TS;
 
 use crate::context::CliContext;
 use crate::prelude::*;
@@ -67,7 +68,8 @@ fn inspect() -> ParentHandler<S9pkPath> {
         )
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
+#[ts(export)]
 struct AddImageParams {
     id: ImageId,
     image: String,
@@ -183,7 +185,8 @@ async fn add_image(
     Ok(())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
+#[ts(export)]
 struct EditManifestParams {
     expression: String,
 }

core/startos/src/s9pk/v1/mod.rs

@@ -2,6 +2,7 @@ use std::path::PathBuf;
 
 use clap::Parser;
 use serde::{Deserialize, Serialize};
+use ts_rs::TS;
 
 pub mod builder;
 pub mod docker;
@@ -12,9 +13,10 @@ pub mod reader;
 
 pub const SIG_CONTEXT: &[u8] = b"s9pk";
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct VerifyParams {
     pub path: PathBuf,
 }

core/startos/src/service/mod.rs

@@ -11,7 +11,9 @@ use rpc_toolkit::{from_fn_async, CallRemoteHandler, Empty, Handler, HandlerArgs}
 use serde::{Deserialize, Serialize};
 use start_stop::StartStop;
 use tokio::sync::Notify;
+use ts_rs::TS;
 
+use crate::action::ActionResult;
 use crate::config::action::ConfigRes;
 use crate::context::{CliContext, RpcContext};
 use crate::core::rpc_continuations::RequestGuid;
@@ -28,8 +30,8 @@ use crate::service::transition::TransitionKind;
 use crate::status::health_check::HealthCheckResult;
 use crate::status::MainStatus;
 use crate::util::actor::{Actor, BackgroundJobs, SimpleActor};
+use crate::util::serde::Pem;
 use crate::volume::data_dir;
-use crate::{action::ActionResult, util::serde::Pem};
 
 pub mod cli;
 mod config;
@@ -498,7 +500,8 @@ impl Actor for ServiceActor {
     }
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
+#[ts(export)]
 pub struct ConnectParams {
     pub id: PackageId,
 }

core/startos/src/service/rpc.rs

@@ -4,6 +4,7 @@ use imbl_value::Value;
 use models::ProcedureName;
 use rpc_toolkit::yajrc::RpcMethod;
 use rpc_toolkit::Empty;
+use ts_rs::TS;
 
 use crate::prelude::*;
 
@@ -43,9 +44,10 @@ impl serde::Serialize for Exit {
     }
 }
 
-#[derive(Clone, serde::Deserialize, serde::Serialize)]
+#[derive(Clone, serde::Deserialize, serde::Serialize, TS)]
 pub struct ExecuteParams {
     procedure: String,
+    #[ts(type = "any")]
     input: Value,
     timeout: Option<u128>,
 }

core/startos/src/setup.rs

@@ -14,6 +14,7 @@ use tokio::io::AsyncWriteExt;
 use tokio::try_join;
 use torut::onion::OnionAddressV3;
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::account::AccountInfo;
 use crate::backup::restore::recover_full_embassy;
@@ -99,10 +100,11 @@ async fn setup_init(
     ))
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
+#[ts(export)]
 pub struct AttachParams {
-    #[serde(rename = "embassy-password")]
+    #[serde(rename = "startOsPassword")]
     password: Option<EncryptedWire>,
     guid: Arc<String>,
 }
@@ -210,8 +212,9 @@ pub fn cifs() -> ParentHandler {
     ParentHandler::new().subcommand("verify", from_fn_async(verify_cifs).no_cli())
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
+#[ts(export)]
 pub struct VerifyCifsParams {
     hostname: String,
     path: PathBuf,
@@ -245,7 +248,7 @@ pub async fn verify_cifs(
     start_os.ok_or_else(|| Error::new(eyre!("No Backup Found"), crate::ErrorKind::NotFound))
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, TS)]
 #[serde(tag = "type")]
 #[serde(rename_all = "camelCase")]
 pub enum RecoverySource {
@@ -253,8 +256,9 @@ pub enum RecoverySource {
     Backup { target: BackupTargetFS },
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
+#[ts(export)]
 pub struct ExecuteParams {
     start_os_logicalname: PathBuf,
     start_os_password: EncryptedWire,

core/startos/src/ssh.rs

@@ -8,6 +8,7 @@ use imbl_value::InternedString;
 use rpc_toolkit::{command, from_fn_async, AnyContext, Empty, HandlerExt, ParentHandler};
 use serde::{Deserialize, Serialize};
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::prelude::*;
@@ -34,7 +35,8 @@ impl Map for SshKeys {
     }
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize, TS)]
+#[ts(type = "string")]
 pub struct SshPubKey(
     #[serde(serialize_with = "crate::util::serde::serialize_display")]
     #[serde(deserialize_with = "crate::util::serde::deserialize_from_str")]
@@ -102,9 +104,10 @@ pub fn ssh() -> ParentHandler {
         )
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct AddParams {
     key: SshPubKey,
 }
@@ -135,10 +138,12 @@ pub async fn add(ctx: RpcContext, AddParams { key }: AddParams) -> Result<SshKey
     Ok(res)
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct DeleteParams {
+    #[ts(type = "string")]
     fingerprint: InternedString,
 }
 

core/startos/src/system.rs

@@ -12,6 +12,7 @@ use tokio::process::Command;
 use tokio::sync::broadcast::Receiver;
 use tokio::sync::RwLock;
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::context::{CliContext, RpcContext};
 use crate::disk::util::{get_available, get_used};
@@ -73,9 +74,10 @@ pub async fn enable_zram() -> Result<(), Error> {
     Ok(())
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct ZramParams {
     enable: bool,
 }
@@ -135,9 +137,10 @@ fn display_governor_info(params: WithIoFormat<GovernorParams>, result: GovernorI
     table.print_tty(false).unwrap();
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct GovernorParams {
     set: Option<Governor>,
 }
@@ -229,11 +232,13 @@ pub async fn time(ctx: RpcContext, _: Empty) -> Result<TimeInfo, Error> {
         uptime: ctx.start_time.elapsed().as_secs(),
     })
 }
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct LogsParams {
     #[arg(short = 'l', long = "limit")]
+    #[ts(type = "number | null")]
     limit: Option<usize>,
     #[arg(short = 'c', long = "cursor")]
     cursor: Option<String>,
@@ -313,11 +318,13 @@ pub async fn logs_follow(
 ) -> Result<LogFollowResponse, Error> {
     follow_logs(ctx, LogSource::System, limit).await
 }
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct KernelLogsParams {
     #[arg(short = 'l', long = "limit")]
+    #[ts(type = "number | null")]
     limit: Option<usize>,
     #[arg(short = 'c', long = "cursor")]
     cursor: Option<String>,

core/startos/src/update/mod.rs

@@ -12,6 +12,7 @@ use serde::{Deserialize, Serialize};
 use tokio::process::Command;
 use tokio_stream::StreamExt;
 use tracing::instrument;
+use ts_rs::TS;
 
 use crate::context::RpcContext;
 use crate::db::model::public::UpdateProgress;
@@ -34,10 +35,12 @@ lazy_static! {
     static ref UPDATED: AtomicBool = AtomicBool::new(false);
 }
 
-#[derive(Deserialize, Serialize, Parser)]
+#[derive(Deserialize, Serialize, Parser, TS)]
 #[serde(rename_all = "camelCase")]
 #[command(rename_all = "kebab-case")]
+#[ts(export)]
 pub struct UpdateSystemParams {
+    #[ts(type = "string")]
     marketplace_url: Url,
 }
 

core/startos/src/util/crypto.rs

@@ -15,6 +15,9 @@ use josekit::jwk::Jwk;
 use serde::{Deserialize, Serialize};
 use sha2::Sha256;
 use tracing::instrument;
+use ts_rs::TS;
+
+use crate::prelude::*;
 
 pub fn pbkdf2(password: impl AsRef<[u8]>, salt: impl AsRef<[u8]>) -> CipherKey<Aes256Ctr> {
     let mut aeskey = CipherKey::<Aes256Ctr>::default();
@@ -53,9 +56,11 @@ pub fn decrypt_slice(input: impl AsRef<[u8]>, password: impl AsRef<[u8]>) -> Vec
     res
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize, TS)]
+#[ts(export)]
 pub struct EncryptedWire {
-    encrypted: serde_json::Value,
+    #[ts(type = "any")]
+    encrypted: Value,
 }
 impl EncryptedWire {
     #[instrument(skip_all)]

core/startos/src/util/serde.rs

@@ -580,7 +580,7 @@ where
     }
 }
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, TS)]
 pub struct StdinDeserializable<T>(pub T);
 impl<T> FromArgMatches for StdinDeserializable<T>
 where