@fressh/react-native-terminal 0.1.0

package/src/generated/shim_uniffi.ts

@@ -0,0 +1,2527 @@
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+import nativeModule from "./shim_uniffi-ffi";
+import {
+  type UniffiRustFutureContinuationCallback,
+  type UniffiForeignFutureDroppedCallback,
+  type UniffiForeignFutureDroppedCallbackStruct,
+  type UniffiVTableCallbackInterfaceShimUniffiFresshEventListener,
+} from "./shim_uniffi-ffi";
+import {
+  type FfiConverter,
+  type UniffiByteArray,
+  type UniffiGcObject,
+  type UniffiHandle,
+  type UniffiObjectFactory,
+  type UniffiReferenceHolder,
+  type UniffiRustCallStatus,
+  AbstractFfiConverterByteArray,
+  FfiConverterArrayBuffer,
+  FfiConverterBool,
+  FfiConverterFloat32,
+  FfiConverterInt32,
+  FfiConverterObject,
+  FfiConverterObjectWithCallbacks,
+  FfiConverterOptional,
+  FfiConverterUInt16,
+  FfiConverterUInt32,
+  FfiConverterUInt64,
+  FfiConverterUInt8,
+  RustBuffer,
+  UniffiAbstractObject,
+  UniffiEnum,
+  UniffiError,
+  UniffiInternalError,
+  UniffiResult,
+  UniffiRustCaller,
+  destructorGuardSymbol,
+  pointerLiteralSymbol,
+  uniffiCreateFfiConverterString,
+  uniffiCreateRecord,
+  uniffiRustCallAsync,
+  uniffiTraitInterfaceCall,
+  uniffiTypeNameSymbol,
+  variantOrdinalSymbol,
+} from "@ubjs/core";
+const uniffiCaller = new UniffiRustCaller(() => ({ code: 0 }));
+
+const uniffiIsDebug =
+  // @ts-ignore -- The process global might not be defined
+  typeof process !== "object" ||
+  // @ts-ignore -- The process global might not be defined
+  process?.env?.NODE_ENV !== "production" ||
+  false;
+
+// Public interface members begin here.
+
+/**
+ * Tear down a preview shell created by [`create_preview`]. Emits no `ShellClosed`
+ * event (preview lifetime is owned by the settings screen, not the session list).
+ */
+export async function closePreview(
+  previewId: string,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<void> {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_close_preview(
+          FfiConverterString.lower(previewId, nativeModule().rustbuffer_alloc)
+        );
+      },
+      /*pollFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_poll_void,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_cancel_void,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_complete_void,
+      /*freeFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_free_void,
+      /*liftFunc:*/ (_v) => {},
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*asyncOpts:*/ asyncOpts_
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+
+/**
+ * Close a shell channel and drop its `Term`.
+ */
+export async function closeShell(
+  shellId: string,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<void> /*throws*/ {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_close_shell(
+          FfiConverterString.lower(shellId, nativeModule().rustbuffer_alloc)
+        );
+      },
+      /*pollFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_poll_void,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_cancel_void,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_complete_void,
+      /*freeFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_free_void,
+      /*liftFunc:*/ (_v) => {},
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*asyncOpts:*/ asyncOpts_,
+      /*errorHandler:*/ FfiConverterTypeSshError.lift.bind(
+        FfiConverterTypeSshError
+      )
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+
+/**
+ * Connect + authenticate. Returns the connection id. A `HostKeyPending` event is
+ * emitted mid-handshake; answer it with [`respond_to_host_key`].
+ */
+export async function connect(
+  details: ConnectionDetails,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<string> /*throws*/ {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_connect(
+          FfiConverterTypeConnectionDetails.lower(
+            details,
+            nativeModule().rustbuffer_alloc
+          )
+        );
+      },
+      /*pollFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_poll_rust_buffer,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_cancel_rust_buffer,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_complete_rust_buffer,
+      /*freeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_free_rust_buffer,
+      // Async returns always go through the JS-side converter: the
+      // FFI symbol returns the future handle (u64), and the user-level
+      // RustBuffer comes back via the shared `rust_future_complete_*`
+      // export. The bytes the runtime hands back must be deserialized
+      // here using the per-callable return-type converter.
+      /*liftFunc:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*asyncOpts:*/ asyncOpts_,
+      /*errorHandler:*/ FfiConverterTypeSshError.lift.bind(
+        FfiConverterTypeSshError
+      )
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+
+/**
+ * Create a non-SSH preview shell fed a canned snippet, bound by `previewId`.
+ * Render it with `<Terminal shellId={previewId} />` — the live config still flows
+ * through, so it reflows as Terminal settings change. Tear down with
+ * [`close_preview`]. Sync (no network round-trip).
+ */
+export function createPreview(previewId: string, demo: ArrayBuffer): void {
+  uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+      nativeModule().ubrn_uniffi_shim_uniffi_fn_func_create_preview(
+        FfiConverterString.lower(previewId, nativeModule().rustbuffer_alloc),
+        FfiConverterArrayBuffer.lower(demo, nativeModule().rustbuffer_alloc),
+        callStatus
+      );
+    },
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+  );
+}
+
+/**
+ * Disconnect a connection (closes its shells first).
+ */
+export async function disconnect(
+  connectionId: string,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<void> /*throws*/ {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_disconnect(
+          FfiConverterString.lower(
+            connectionId,
+            nativeModule().rustbuffer_alloc
+          )
+        );
+      },
+      /*pollFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_poll_void,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_cancel_void,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_complete_void,
+      /*freeFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_free_void,
+      /*liftFunc:*/ (_v) => {},
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*asyncOpts:*/ asyncOpts_,
+      /*errorHandler:*/ FfiConverterTypeSshError.lift.bind(
+        FfiConverterTypeSshError
+      )
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+
+/**
+ * Generate a new key pair (OpenSSH private-key string).
+ */
+export function generateKeyPair(keyType: KeyType): string /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterString.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeSshError.lift.bind(
+        FfiConverterTypeSshError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_generate_key_pair(
+          FfiConverterTypeKeyType.lower(
+            keyType,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Resize a shell's terminal.
+ */
+export async function resize(
+  shellId: string,
+  cols: number,
+  rows: number,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<void> /*throws*/ {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_resize(
+          FfiConverterString.lower(shellId, nativeModule().rustbuffer_alloc),
+          FfiConverterUInt32.lower(cols, nativeModule().rustbuffer_alloc),
+          FfiConverterUInt32.lower(rows, nativeModule().rustbuffer_alloc)
+        );
+      },
+      /*pollFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_poll_void,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_cancel_void,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_complete_void,
+      /*freeFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_free_void,
+      /*liftFunc:*/ (_v) => {},
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*asyncOpts:*/ asyncOpts_,
+      /*errorHandler:*/ FfiConverterTypeSshError.lift.bind(
+        FfiConverterTypeSshError
+      )
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+
+/**
+ * Resume a parked host-key decision (accept/reject the server key).
+ */
+export function respondToHostKey(connectionId: string, accept: boolean): void {
+  uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+      nativeModule().ubrn_uniffi_shim_uniffi_fn_func_respond_to_host_key(
+        FfiConverterString.lower(connectionId, nativeModule().rustbuffer_alloc),
+        FfiConverterBool.lower(accept, nativeModule().rustbuffer_alloc),
+        callStatus
+      );
+    },
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+  );
+}
+
+/**
+ * Run a one-off command on an existing connection without a PTY/shell. The
+ * interactive shell (if any) is untouched. Note: runs in the login/home dir — an
+ * `exec` channel does NOT inherit a live shell's cwd (use `cd … && …` if needed).
+ */
+export async function runCommand(
+  connectionId: string,
+  command: string,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<CommandResult> /*throws*/ {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_run_command(
+          FfiConverterString.lower(
+            connectionId,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterString.lower(command, nativeModule().rustbuffer_alloc)
+        );
+      },
+      /*pollFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_poll_rust_buffer,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_cancel_rust_buffer,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_complete_rust_buffer,
+      /*freeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_free_rust_buffer,
+      // Async returns always go through the JS-side converter: the
+      // FFI symbol returns the future handle (u64), and the user-level
+      // RustBuffer comes back via the shared `rust_future_complete_*`
+      // export. The bytes the runtime hands back must be deserialized
+      // here using the per-callable return-type converter.
+      /*liftFunc:*/ FfiConverterTypeCommandResult.lift.bind(
+        FfiConverterTypeCommandResult
+      ),
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*asyncOpts:*/ asyncOpts_,
+      /*errorHandler:*/ FfiConverterTypeSshError.lift.bind(
+        FfiConverterTypeSshError
+      )
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+
+/**
+ * Scroll a shell by `delta_px` physical px (positive = finger dragged down =
+ * older content). Honors mouse-reporting / alt-screen modes; otherwise moves the
+ * scrollback viewport. Touch gestures live in JS and call this by `shellId`.
+ */
+export async function scroll(
+  shellId: string,
+  deltaPx: number,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<void> /*throws*/ {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_scroll(
+          FfiConverterString.lower(shellId, nativeModule().rustbuffer_alloc),
+          FfiConverterFloat32.lower(deltaPx, nativeModule().rustbuffer_alloc)
+        );
+      },
+      /*pollFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_poll_void,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_cancel_void,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_complete_void,
+      /*freeFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_free_void,
+      /*liftFunc:*/ (_v) => {},
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*asyncOpts:*/ asyncOpts_,
+      /*errorHandler:*/ FfiConverterTypeSshError.lift.bind(
+        FfiConverterTypeSshError
+      )
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+
+/**
+ * Clear any active selection.
+ */
+export function selectionClear(shellId: string): void {
+  uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+      nativeModule().ubrn_uniffi_shim_uniffi_fn_func_selection_clear(
+        FfiConverterString.lower(shellId, nativeModule().rustbuffer_alloc),
+        callStatus
+      );
+    },
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+  );
+}
+
+/**
+ * Begin a selection at a touch point (physical px, surface-relative).
+ */
+export function selectionStart(
+  shellId: string,
+  x: number,
+  y: number,
+  kind: SelectionKind
+): void {
+  uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+      nativeModule().ubrn_uniffi_shim_uniffi_fn_func_selection_start(
+        FfiConverterString.lower(shellId, nativeModule().rustbuffer_alloc),
+        FfiConverterFloat32.lower(x, nativeModule().rustbuffer_alloc),
+        FfiConverterFloat32.lower(y, nativeModule().rustbuffer_alloc),
+        FfiConverterTypeSelectionKind.lower(
+          kind,
+          nativeModule().rustbuffer_alloc
+        ),
+        callStatus
+      );
+    },
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+  );
+}
+
+/**
+ * The currently selected text, if any.
+ */
+export function selectionText(shellId: string): string | undefined {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterOptionalString.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_selection_text(
+          FfiConverterString.lower(shellId, nativeModule().rustbuffer_alloc),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+/**
+ * Extend the active selection to a touch point (physical px).
+ */
+export function selectionUpdate(shellId: string, x: number, y: number): void {
+  uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+      nativeModule().ubrn_uniffi_shim_uniffi_fn_func_selection_update(
+        FfiConverterString.lower(shellId, nativeModule().rustbuffer_alloc),
+        FfiConverterFloat32.lower(x, nativeModule().rustbuffer_alloc),
+        FfiConverterFloat32.lower(y, nativeModule().rustbuffer_alloc),
+        callStatus
+      );
+    },
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+  );
+}
+
+/**
+ * Send user input (stdin) to a shell. (Also available on the render plane.)
+ */
+export async function sendData(
+  shellId: string,
+  data: ArrayBuffer,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<void> /*throws*/ {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_send_data(
+          FfiConverterString.lower(shellId, nativeModule().rustbuffer_alloc),
+          FfiConverterArrayBuffer.lower(data, nativeModule().rustbuffer_alloc)
+        );
+      },
+      /*pollFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_poll_void,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_cancel_void,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_complete_void,
+      /*freeFunc:*/ nativeModule().ubrn_ffi_shim_uniffi_rust_future_free_void,
+      /*liftFunc:*/ (_v) => {},
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*asyncOpts:*/ asyncOpts_,
+      /*errorHandler:*/ FfiConverterTypeSshError.lift.bind(
+        FfiConverterTypeSshError
+      )
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+
+/**
+ * Install the JS event listener. Call once at module init.
+ */
+export function setEventListener(listener: FresshEventListener): void {
+  uniffiCaller.rustCall(
+    /*caller:*/ (callStatus) => {
+      nativeModule().ubrn_uniffi_shim_uniffi_fn_func_set_event_listener(
+        FfiConverterTypeFresshEventListener.lower(
+          listener,
+          nativeModule().rustbuffer_alloc
+        ),
+        callStatus
+      );
+    },
+    /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+  );
+}
+
+/**
+ * Open a PTY + shell, returning the new shell id. Render with `<Terminal shellId=…/>`.
+ */
+export async function startShell(
+  connectionId: string,
+  options: ShellOptions,
+  asyncOpts_?: { signal: AbortSignal }
+): Promise<string> /*throws*/ {
+  const __stack = uniffiIsDebug ? new Error().stack : undefined;
+  try {
+    return await uniffiRustCallAsync(
+      /*rustCaller:*/ uniffiCaller,
+      /*rustFutureFunc:*/ () => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_start_shell(
+          FfiConverterString.lower(
+            connectionId,
+            nativeModule().rustbuffer_alloc
+          ),
+          FfiConverterTypeShellOptions.lower(
+            options,
+            nativeModule().rustbuffer_alloc
+          )
+        );
+      },
+      /*pollFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_poll_rust_buffer,
+      /*cancelFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_cancel_rust_buffer,
+      /*completeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_complete_rust_buffer,
+      /*freeFunc:*/ nativeModule()
+        .ubrn_ffi_shim_uniffi_rust_future_free_rust_buffer,
+      // Async returns always go through the JS-side converter: the
+      // FFI symbol returns the future handle (u64), and the user-level
+      // RustBuffer comes back via the shared `rust_future_complete_*`
+      // export. The bytes the runtime hands back must be deserialized
+      // here using the per-callable return-type converter.
+      /*liftFunc:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString),
+      /*asyncOpts:*/ asyncOpts_,
+      /*errorHandler:*/ FfiConverterTypeSshError.lift.bind(
+        FfiConverterTypeSshError
+      )
+    );
+  } catch (__error: any) {
+    if (uniffiIsDebug && __error instanceof Error) {
+      __error.stack = __stack;
+    }
+    throw __error;
+  }
+}
+
+/**
+ * Validate a private key; returns its canonical OpenSSH form.
+ */
+export function validatePrivateKey(pem: string): string /*throws*/ {
+  return ((__rb: Uint8Array) => {
+    try {
+      return FfiConverterString.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  })(
+    uniffiCaller.rustCallWithError(
+      /*liftError:*/ FfiConverterTypeSshError.lift.bind(
+        FfiConverterTypeSshError
+      ),
+      /*caller:*/ (callStatus) => {
+        return nativeModule().ubrn_uniffi_shim_uniffi_fn_func_validate_private_key(
+          FfiConverterString.lower(pem, nativeModule().rustbuffer_alloc),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    )
+  );
+}
+
+// Hermes (React Native ≥ 0.74) ships TextEncoder and encodeInto, but not
+// TextDecoder. For single-string decode (bytesToString), we polyfill via the
+// C++ string_from_buffer helper using a duck-typed object matching the
+// standard TextDecoder.decode signature. Once Hermes ships a real
+// TextDecoder, the `typeof` check will pick it up automatically.
+//
+// For array-of-strings decode (readStringFromBuffer), we keep a dedicated C++
+// helper: the polyfill path (new Uint8Array view + decode) measured ~40%
+// slower on getStringArray benchmarks than a direct (buf, offset, length)
+// call, due to the per-read view allocation and extra property lookups in
+// string_from_buffer.
+const stringConverter = (() => {
+  const encoder = new TextEncoder();
+  const decoder: { decode(input: UniffiByteArray): string } =
+    typeof TextDecoder !== "undefined"
+      ? new TextDecoder()
+      : {
+          decode: (bytes: UniffiByteArray) =>
+            nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_from_buffer(
+              bytes,
+              undefined as any
+            ) as string,
+        };
+  return {
+    // Single-string lower() uses the C++ helper — TextEncoder.encode
+    // measured ~43% slower on takeString benchmarks.
+    stringToBytes: (s: string) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_buffer(
+        s,
+        undefined as any
+      ),
+    bytesToString: (ab: UniffiByteArray) => decoder.decode(ab),
+    // Direct C++ call — bypasses uniffiCaller.rustCall() overhead.
+    // Matters for N-element arrays.
+    stringByteLength: (s: string) =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(
+        s,
+        undefined as any
+      ) as number,
+    // Encode directly into the RustBuffer backing store via
+    // TextEncoder.encodeInto — zero intermediate allocation. Replaces
+    // the old C++ write_string_into_buffer helper.
+    writeStringIntoBuffer: (s: string, buf: any, offset: number): number => {
+      const view = new Uint8Array(
+        buf.arrayBuffer,
+        offset,
+        buf.arrayBuffer.byteLength - offset
+      );
+      return encoder.encodeInto(s, view).written;
+    },
+    // Dedicated C++ helper — avoids per-read Uint8Array allocation and
+    // the double property-lookup in string_from_buffer.
+    readStringFromBuffer: (buf: any, offset: number, length: number): string =>
+      nativeModule().ubrn_uniffi_internal_fn_func_ffi__read_string_from_buffer(
+        buf,
+        offset,
+        length
+      ) as string,
+  };
+})();
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+/**
+ * Output of a one-off [`run_command`]: stdout/stderr decoded UTF-8-lossy (for
+ * display) + the exit code (absent if killed by a signal).
+ */
+export type CommandResult = {
+  stdout: string;
+  stderr: string;
+  exitCode?: number;
+};
+
+/**
+ * Generated factory for {@link CommandResult} record objects.
+ */
+export const CommandResult = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<CommandResult, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<CommandResult>,
+  });
+})();
+
+const FfiConverterTypeCommandResult = (() => {
+  type TypeName = CommandResult;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        stdout: FfiConverterString.read(from),
+        stderr: FfiConverterString.read(from),
+        exitCode: FfiConverterOptionalInt32.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.stdout, into);
+      FfiConverterString.write(value.stderr, into);
+      FfiConverterOptionalInt32.write(value.exitCode, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.stdout) +
+        FfiConverterString.allocationSize(value.stderr) +
+        FfiConverterOptionalInt32.allocationSize(value.exitCode)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Enum: Security
+export enum Security_Tags {
+  Password = "Password",
+  Key = "Key",
+}
+export const Security = (() => {
+  type Password__interface = {
+    tag: Security_Tags.Password;
+    inner: Readonly<{ password: string }>;
+  };
+  class Password_ extends UniffiEnum implements Password__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "Security";
+    readonly tag = Security_Tags.Password;
+    readonly inner: Readonly<{ password: string }>;
+    constructor(inner: { password: string }) {
+      super("Security", "Password");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { password: string }): Password_ {
+      return new Password_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Password_ {
+      return obj.tag === Security_Tags.Password;
+    }
+  }
+
+  type Key__interface = {
+    tag: Security_Tags.Key;
+    inner: Readonly<{ privateKeyContent: string }>;
+  };
+  class Key_ extends UniffiEnum implements Key__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "Security";
+    readonly tag = Security_Tags.Key;
+    readonly inner: Readonly<{ privateKeyContent: string }>;
+    constructor(inner: { privateKeyContent: string }) {
+      super("Security", "Key");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { privateKeyContent: string }): Key_ {
+      return new Key_(inner);
+    }
+
+    static instanceOf(obj: any): obj is Key_ {
+      return obj.tag === Security_Tags.Key;
+    }
+  }
+
+  function instanceOf(obj: any): obj is Security {
+    return obj[uniffiTypeNameSymbol] === "Security";
+  }
+
+  return Object.freeze({
+    instanceOf,
+    Password: Password_,
+    Key: Key_,
+  });
+})();
+export type Security = InstanceType<(typeof Security)["Password" | "Key"]>;
+
+// FfiConverter for enum Security
+const FfiConverterTypeSecurity = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = Security;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new Security.Password({
+            password: FfiConverterString.read(from),
+          });
+        case 2:
+          return new Security.Key({
+            privateKeyContent: FfiConverterString.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case Security_Tags.Password: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.password, into);
+          return;
+        }
+        case Security_Tags.Key: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.privateKeyContent, into);
+          return;
+        }
+        default:
+          // Throwing from here means that Security_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case Security_Tags.Password: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterString.allocationSize(inner.password);
+          return size;
+        }
+        case Security_Tags.Key: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterString.allocationSize(inner.privateKeyContent);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type ConnectionDetails = {
+  host: string;
+  port: number;
+  username: string;
+  security: Security;
+};
+
+/**
+ * Generated factory for {@link ConnectionDetails} record objects.
+ */
+export const ConnectionDetails = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ConnectionDetails, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<ConnectionDetails>,
+  });
+})();
+
+const FfiConverterTypeConnectionDetails = (() => {
+  type TypeName = ConnectionDetails;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        host: FfiConverterString.read(from),
+        port: FfiConverterUInt16.read(from),
+        username: FfiConverterString.read(from),
+        security: FfiConverterTypeSecurity.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.host, into);
+      FfiConverterUInt16.write(value.port, into);
+      FfiConverterString.write(value.username, into);
+      FfiConverterTypeSecurity.write(value.security, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.host) +
+        FfiConverterUInt16.allocationSize(value.port) +
+        FfiConverterString.allocationSize(value.username) +
+        FfiConverterTypeSecurity.allocationSize(value.security)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type ServerPublicKeyInfo = {
+  host: string;
+  port: number;
+  remoteIp?: string;
+  algorithm: string;
+  fingerprintSha256: string;
+  keyBase64: string;
+};
+
+/**
+ * Generated factory for {@link ServerPublicKeyInfo} record objects.
+ */
+export const ServerPublicKeyInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ServerPublicKeyInfo, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<ServerPublicKeyInfo>,
+  });
+})();
+
+const FfiConverterTypeServerPublicKeyInfo = (() => {
+  type TypeName = ServerPublicKeyInfo;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        host: FfiConverterString.read(from),
+        port: FfiConverterUInt16.read(from),
+        remoteIp: FfiConverterOptionalString.read(from),
+        algorithm: FfiConverterString.read(from),
+        fingerprintSha256: FfiConverterString.read(from),
+        keyBase64: FfiConverterString.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterString.write(value.host, into);
+      FfiConverterUInt16.write(value.port, into);
+      FfiConverterOptionalString.write(value.remoteIp, into);
+      FfiConverterString.write(value.algorithm, into);
+      FfiConverterString.write(value.fingerprintSha256, into);
+      FfiConverterString.write(value.keyBase64, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterString.allocationSize(value.host) +
+        FfiConverterUInt16.allocationSize(value.port) +
+        FfiConverterOptionalString.allocationSize(value.remoteIp) +
+        FfiConverterString.allocationSize(value.algorithm) +
+        FfiConverterString.allocationSize(value.fingerprintSha256) +
+        FfiConverterString.allocationSize(value.keyBase64)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export enum TerminalType {
+  Vanilla,
+  Vt100,
+  Vt102,
+  Vt220,
+  Ansi,
+  Xterm,
+  Xterm256,
+}
+
+const FfiConverterTypeTerminalType = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = TerminalType;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return TerminalType.Vanilla;
+        case 2:
+          return TerminalType.Vt100;
+        case 3:
+          return TerminalType.Vt102;
+        case 4:
+          return TerminalType.Vt220;
+        case 5:
+          return TerminalType.Ansi;
+        case 6:
+          return TerminalType.Xterm;
+        case 7:
+          return TerminalType.Xterm256;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case TerminalType.Vanilla:
+          return ordinalConverter.write(1, into);
+        case TerminalType.Vt100:
+          return ordinalConverter.write(2, into);
+        case TerminalType.Vt102:
+          return ordinalConverter.write(3, into);
+        case TerminalType.Vt220:
+          return ordinalConverter.write(4, into);
+        case TerminalType.Ansi:
+          return ordinalConverter.write(5, into);
+        case TerminalType.Xterm:
+          return ordinalConverter.write(6, into);
+        case TerminalType.Xterm256:
+          return ordinalConverter.write(7, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+export type ShellOptions = {
+  term: TerminalType;
+  cols: number;
+  rows: number;
+  scrollbackLines: number;
+  /**
+   * Auto-inject OSC 633 shell integration on connect (cwd / command lifecycle /
+   * exit code / command text). `None` ⇒ default on. Set `false` from the app's
+   * global kill-switch / per-host toggle to behave like a plain SSH client.
+   */
+  shellIntegration?: boolean;
+};
+
+/**
+ * Generated factory for {@link ShellOptions} record objects.
+ */
+export const ShellOptions = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord<ShellOptions, ReturnType<typeof defaults>>(
+      defaults
+    );
+  })();
+  return Object.freeze({
+    create,
+    new: create,
+    defaults: () => Object.freeze(defaults()) as Partial<ShellOptions>,
+  });
+})();
+
+const FfiConverterTypeShellOptions = (() => {
+  type TypeName = ShellOptions;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      return {
+        term: FfiConverterTypeTerminalType.read(from),
+        cols: FfiConverterUInt32.read(from),
+        rows: FfiConverterUInt32.read(from),
+        scrollbackLines: FfiConverterUInt32.read(from),
+        shellIntegration: FfiConverterOptionalBoolean.read(from),
+      };
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      FfiConverterTypeTerminalType.write(value.term, into);
+      FfiConverterUInt32.write(value.cols, into);
+      FfiConverterUInt32.write(value.rows, into);
+      FfiConverterUInt32.write(value.scrollbackLines, into);
+      FfiConverterOptionalBoolean.write(value.shellIntegration, into);
+    }
+    allocationSize(value: TypeName): number {
+      return (
+        FfiConverterTypeTerminalType.allocationSize(value.term) +
+        FfiConverterUInt32.allocationSize(value.cols) +
+        FfiConverterUInt32.allocationSize(value.rows) +
+        FfiConverterUInt32.allocationSize(value.scrollbackLines) +
+        FfiConverterOptionalBoolean.allocationSize(value.shellIntegration)
+      );
+    }
+  }
+  return new FFIConverter();
+})();
+
+export enum SshConnectionProgressEvent {
+  TcpConnected,
+  SshHandshake,
+}
+
+const FfiConverterTypeSshConnectionProgressEvent = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = SshConnectionProgressEvent;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return SshConnectionProgressEvent.TcpConnected;
+        case 2:
+          return SshConnectionProgressEvent.SshHandshake;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case SshConnectionProgressEvent.TcpConnected:
+          return ordinalConverter.write(1, into);
+        case SshConnectionProgressEvent.SshHandshake:
+          return ordinalConverter.write(2, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Enum: FresshEvent
+export enum FresshEvent_Tags {
+  ConnectProgress = "ConnectProgress",
+  HostKeyPending = "HostKeyPending",
+  ConnectionClosed = "ConnectionClosed",
+  ShellClosed = "ShellClosed",
+  WorkingDirectoryChanged = "WorkingDirectoryChanged",
+  PromptStart = "PromptStart",
+  CommandStart = "CommandStart",
+  CommandFinished = "CommandFinished",
+  CommandText = "CommandText",
+}
+export const FresshEvent = (() => {
+  type ConnectProgress__interface = {
+    tag: FresshEvent_Tags.ConnectProgress;
+    inner: Readonly<{
+      connectionId: string;
+      event: SshConnectionProgressEvent;
+    }>;
+  };
+  class ConnectProgress_
+    extends UniffiEnum
+    implements ConnectProgress__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "FresshEvent";
+    readonly tag = FresshEvent_Tags.ConnectProgress;
+    readonly inner: Readonly<{
+      connectionId: string;
+      event: SshConnectionProgressEvent;
+    }>;
+    constructor(inner: {
+      connectionId: string;
+      event: SshConnectionProgressEvent;
+    }) {
+      super("FresshEvent", "ConnectProgress");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: {
+      connectionId: string;
+      event: SshConnectionProgressEvent;
+    }): ConnectProgress_ {
+      return new ConnectProgress_(inner);
+    }
+
+    static instanceOf(obj: any): obj is ConnectProgress_ {
+      return obj.tag === FresshEvent_Tags.ConnectProgress;
+    }
+  }
+
+  type HostKeyPending__interface = {
+    tag: FresshEvent_Tags.HostKeyPending;
+    inner: Readonly<{ connectionId: string; info: ServerPublicKeyInfo }>;
+  };
+  class HostKeyPending_
+    extends UniffiEnum
+    implements HostKeyPending__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "FresshEvent";
+    readonly tag = FresshEvent_Tags.HostKeyPending;
+    readonly inner: Readonly<{
+      connectionId: string;
+      info: ServerPublicKeyInfo;
+    }>;
+    constructor(inner: { connectionId: string; info: ServerPublicKeyInfo }) {
+      super("FresshEvent", "HostKeyPending");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: {
+      connectionId: string;
+      info: ServerPublicKeyInfo;
+    }): HostKeyPending_ {
+      return new HostKeyPending_(inner);
+    }
+
+    static instanceOf(obj: any): obj is HostKeyPending_ {
+      return obj.tag === FresshEvent_Tags.HostKeyPending;
+    }
+  }
+
+  type ConnectionClosed__interface = {
+    tag: FresshEvent_Tags.ConnectionClosed;
+    inner: Readonly<{ connectionId: string }>;
+  };
+  class ConnectionClosed_
+    extends UniffiEnum
+    implements ConnectionClosed__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "FresshEvent";
+    readonly tag = FresshEvent_Tags.ConnectionClosed;
+    readonly inner: Readonly<{ connectionId: string }>;
+    constructor(inner: { connectionId: string }) {
+      super("FresshEvent", "ConnectionClosed");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { connectionId: string }): ConnectionClosed_ {
+      return new ConnectionClosed_(inner);
+    }
+
+    static instanceOf(obj: any): obj is ConnectionClosed_ {
+      return obj.tag === FresshEvent_Tags.ConnectionClosed;
+    }
+  }
+
+  type ShellClosed__interface = {
+    tag: FresshEvent_Tags.ShellClosed;
+    inner: Readonly<{ shellId: string }>;
+  };
+  class ShellClosed_ extends UniffiEnum implements ShellClosed__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "FresshEvent";
+    readonly tag = FresshEvent_Tags.ShellClosed;
+    readonly inner: Readonly<{ shellId: string }>;
+    constructor(inner: { shellId: string }) {
+      super("FresshEvent", "ShellClosed");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { shellId: string }): ShellClosed_ {
+      return new ShellClosed_(inner);
+    }
+
+    static instanceOf(obj: any): obj is ShellClosed_ {
+      return obj.tag === FresshEvent_Tags.ShellClosed;
+    }
+  }
+
+  type WorkingDirectoryChanged__interface = {
+    tag: FresshEvent_Tags.WorkingDirectoryChanged;
+    inner: Readonly<{ shellId: string; path: string }>;
+  };
+  class WorkingDirectoryChanged_
+    extends UniffiEnum
+    implements WorkingDirectoryChanged__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "FresshEvent";
+    readonly tag = FresshEvent_Tags.WorkingDirectoryChanged;
+    readonly inner: Readonly<{ shellId: string; path: string }>;
+    constructor(inner: { shellId: string; path: string }) {
+      super("FresshEvent", "WorkingDirectoryChanged");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: {
+      shellId: string;
+      path: string;
+    }): WorkingDirectoryChanged_ {
+      return new WorkingDirectoryChanged_(inner);
+    }
+
+    static instanceOf(obj: any): obj is WorkingDirectoryChanged_ {
+      return obj.tag === FresshEvent_Tags.WorkingDirectoryChanged;
+    }
+  }
+
+  type PromptStart__interface = {
+    tag: FresshEvent_Tags.PromptStart;
+    inner: Readonly<{ shellId: string }>;
+  };
+  class PromptStart_ extends UniffiEnum implements PromptStart__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "FresshEvent";
+    readonly tag = FresshEvent_Tags.PromptStart;
+    readonly inner: Readonly<{ shellId: string }>;
+    constructor(inner: { shellId: string }) {
+      super("FresshEvent", "PromptStart");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { shellId: string }): PromptStart_ {
+      return new PromptStart_(inner);
+    }
+
+    static instanceOf(obj: any): obj is PromptStart_ {
+      return obj.tag === FresshEvent_Tags.PromptStart;
+    }
+  }
+
+  type CommandStart__interface = {
+    tag: FresshEvent_Tags.CommandStart;
+    inner: Readonly<{ shellId: string }>;
+  };
+  class CommandStart_ extends UniffiEnum implements CommandStart__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "FresshEvent";
+    readonly tag = FresshEvent_Tags.CommandStart;
+    readonly inner: Readonly<{ shellId: string }>;
+    constructor(inner: { shellId: string }) {
+      super("FresshEvent", "CommandStart");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { shellId: string }): CommandStart_ {
+      return new CommandStart_(inner);
+    }
+
+    static instanceOf(obj: any): obj is CommandStart_ {
+      return obj.tag === FresshEvent_Tags.CommandStart;
+    }
+  }
+
+  type CommandFinished__interface = {
+    tag: FresshEvent_Tags.CommandFinished;
+    inner: Readonly<{
+      shellId: string;
+      exitCode?: number;
+      durationMs?: bigint;
+    }>;
+  };
+  class CommandFinished_
+    extends UniffiEnum
+    implements CommandFinished__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "FresshEvent";
+    readonly tag = FresshEvent_Tags.CommandFinished;
+    readonly inner: Readonly<{
+      shellId: string;
+      exitCode?: number;
+      durationMs?: bigint;
+    }>;
+    constructor(inner: {
+      shellId: string;
+      exitCode?: number;
+      durationMs?: bigint;
+    }) {
+      super("FresshEvent", "CommandFinished");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: {
+      shellId: string;
+      exitCode?: number;
+      durationMs?: bigint;
+    }): CommandFinished_ {
+      return new CommandFinished_(inner);
+    }
+
+    static instanceOf(obj: any): obj is CommandFinished_ {
+      return obj.tag === FresshEvent_Tags.CommandFinished;
+    }
+  }
+
+  type CommandText__interface = {
+    tag: FresshEvent_Tags.CommandText;
+    inner: Readonly<{ shellId: string; command: string }>;
+  };
+  class CommandText_ extends UniffiEnum implements CommandText__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "FresshEvent";
+    readonly tag = FresshEvent_Tags.CommandText;
+    readonly inner: Readonly<{ shellId: string; command: string }>;
+    constructor(inner: { shellId: string; command: string }) {
+      super("FresshEvent", "CommandText");
+
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner: { shellId: string; command: string }): CommandText_ {
+      return new CommandText_(inner);
+    }
+
+    static instanceOf(obj: any): obj is CommandText_ {
+      return obj.tag === FresshEvent_Tags.CommandText;
+    }
+  }
+
+  function instanceOf(obj: any): obj is FresshEvent {
+    return obj[uniffiTypeNameSymbol] === "FresshEvent";
+  }
+
+  return Object.freeze({
+    instanceOf,
+    ConnectProgress: ConnectProgress_,
+    HostKeyPending: HostKeyPending_,
+    ConnectionClosed: ConnectionClosed_,
+    ShellClosed: ShellClosed_,
+    WorkingDirectoryChanged: WorkingDirectoryChanged_,
+    PromptStart: PromptStart_,
+    CommandStart: CommandStart_,
+    CommandFinished: CommandFinished_,
+    CommandText: CommandText_,
+  });
+})();
+export type FresshEvent = InstanceType<
+  (typeof FresshEvent)[
+    | "ConnectProgress"
+    | "HostKeyPending"
+    | "ConnectionClosed"
+    | "ShellClosed"
+    | "WorkingDirectoryChanged"
+    | "PromptStart"
+    | "CommandStart"
+    | "CommandFinished"
+    | "CommandText"]
+>;
+
+// FfiConverter for enum FresshEvent
+const FfiConverterTypeFresshEvent = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = FresshEvent;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new FresshEvent.ConnectProgress({
+            connectionId: FfiConverterString.read(from),
+            event: FfiConverterTypeSshConnectionProgressEvent.read(from),
+          });
+        case 2:
+          return new FresshEvent.HostKeyPending({
+            connectionId: FfiConverterString.read(from),
+            info: FfiConverterTypeServerPublicKeyInfo.read(from),
+          });
+        case 3:
+          return new FresshEvent.ConnectionClosed({
+            connectionId: FfiConverterString.read(from),
+          });
+        case 4:
+          return new FresshEvent.ShellClosed({
+            shellId: FfiConverterString.read(from),
+          });
+        case 5:
+          return new FresshEvent.WorkingDirectoryChanged({
+            shellId: FfiConverterString.read(from),
+            path: FfiConverterString.read(from),
+          });
+        case 6:
+          return new FresshEvent.PromptStart({
+            shellId: FfiConverterString.read(from),
+          });
+        case 7:
+          return new FresshEvent.CommandStart({
+            shellId: FfiConverterString.read(from),
+          });
+        case 8:
+          return new FresshEvent.CommandFinished({
+            shellId: FfiConverterString.read(from),
+            exitCode: FfiConverterOptionalInt32.read(from),
+            durationMs: FfiConverterOptionalUInt64.read(from),
+          });
+        case 9:
+          return new FresshEvent.CommandText({
+            shellId: FfiConverterString.read(from),
+            command: FfiConverterString.read(from),
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case FresshEvent_Tags.ConnectProgress: {
+          ordinalConverter.write(1, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.connectionId, into);
+          FfiConverterTypeSshConnectionProgressEvent.write(inner.event, into);
+          return;
+        }
+        case FresshEvent_Tags.HostKeyPending: {
+          ordinalConverter.write(2, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.connectionId, into);
+          FfiConverterTypeServerPublicKeyInfo.write(inner.info, into);
+          return;
+        }
+        case FresshEvent_Tags.ConnectionClosed: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.connectionId, into);
+          return;
+        }
+        case FresshEvent_Tags.ShellClosed: {
+          ordinalConverter.write(4, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.shellId, into);
+          return;
+        }
+        case FresshEvent_Tags.WorkingDirectoryChanged: {
+          ordinalConverter.write(5, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.shellId, into);
+          FfiConverterString.write(inner.path, into);
+          return;
+        }
+        case FresshEvent_Tags.PromptStart: {
+          ordinalConverter.write(6, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.shellId, into);
+          return;
+        }
+        case FresshEvent_Tags.CommandStart: {
+          ordinalConverter.write(7, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.shellId, into);
+          return;
+        }
+        case FresshEvent_Tags.CommandFinished: {
+          ordinalConverter.write(8, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.shellId, into);
+          FfiConverterOptionalInt32.write(inner.exitCode, into);
+          FfiConverterOptionalUInt64.write(inner.durationMs, into);
+          return;
+        }
+        case FresshEvent_Tags.CommandText: {
+          ordinalConverter.write(9, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.shellId, into);
+          FfiConverterString.write(inner.command, into);
+          return;
+        }
+        default:
+          // Throwing from here means that FresshEvent_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case FresshEvent_Tags.ConnectProgress: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(1);
+          size += FfiConverterString.allocationSize(inner.connectionId);
+          size += FfiConverterTypeSshConnectionProgressEvent.allocationSize(
+            inner.event
+          );
+          return size;
+        }
+        case FresshEvent_Tags.HostKeyPending: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(2);
+          size += FfiConverterString.allocationSize(inner.connectionId);
+          size += FfiConverterTypeServerPublicKeyInfo.allocationSize(
+            inner.info
+          );
+          return size;
+        }
+        case FresshEvent_Tags.ConnectionClosed: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterString.allocationSize(inner.connectionId);
+          return size;
+        }
+        case FresshEvent_Tags.ShellClosed: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(4);
+          size += FfiConverterString.allocationSize(inner.shellId);
+          return size;
+        }
+        case FresshEvent_Tags.WorkingDirectoryChanged: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(5);
+          size += FfiConverterString.allocationSize(inner.shellId);
+          size += FfiConverterString.allocationSize(inner.path);
+          return size;
+        }
+        case FresshEvent_Tags.PromptStart: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(6);
+          size += FfiConverterString.allocationSize(inner.shellId);
+          return size;
+        }
+        case FresshEvent_Tags.CommandStart: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(7);
+          size += FfiConverterString.allocationSize(inner.shellId);
+          return size;
+        }
+        case FresshEvent_Tags.CommandFinished: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(8);
+          size += FfiConverterString.allocationSize(inner.shellId);
+          size += FfiConverterOptionalInt32.allocationSize(inner.exitCode);
+          size += FfiConverterOptionalUInt64.allocationSize(inner.durationMs);
+          return size;
+        }
+        case FresshEvent_Tags.CommandText: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(9);
+          size += FfiConverterString.allocationSize(inner.shellId);
+          size += FfiConverterString.allocationSize(inner.command);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+export enum KeyType {
+  Rsa,
+  Ecdsa,
+  Ed25519,
+  Ed448,
+}
+
+const FfiConverterTypeKeyType = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = KeyType;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return KeyType.Rsa;
+        case 2:
+          return KeyType.Ecdsa;
+        case 3:
+          return KeyType.Ed25519;
+        case 4:
+          return KeyType.Ed448;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case KeyType.Rsa:
+          return ordinalConverter.write(1, into);
+        case KeyType.Ecdsa:
+          return ordinalConverter.write(2, into);
+        case KeyType.Ed25519:
+          return ordinalConverter.write(3, into);
+        case KeyType.Ed448:
+          return ordinalConverter.write(4, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Which kind of selection a touch starts. Maps to `fressh_core::SelectionKind`.
+ */
+export enum SelectionKind {
+  Simple,
+  Word,
+  Line,
+}
+
+const FfiConverterTypeSelectionKind = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = SelectionKind;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return SelectionKind.Simple;
+        case 2:
+          return SelectionKind.Word;
+        case 3:
+          return SelectionKind.Line;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value) {
+        case SelectionKind.Simple:
+          return ordinalConverter.write(1, into);
+        case SelectionKind.Word:
+          return ordinalConverter.write(2, into);
+        case SelectionKind.Line:
+          return ordinalConverter.write(3, into);
+      }
+    }
+    allocationSize(value: TypeName): number {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+// Error type: SshError
+export enum SshError_Tags {
+  Disconnected = "Disconnected",
+  UnsupportedKeyType = "UnsupportedKeyType",
+  Auth = "Auth",
+  ShellAlreadyRunning = "ShellAlreadyRunning",
+  HostKeyRejected = "HostKeyRejected",
+  NotFound = "NotFound",
+  Ssh = "Ssh",
+  Keys = "Keys",
+}
+export const SshError = (() => {
+  type Disconnected__interface = {
+    tag: SshError_Tags.Disconnected;
+  };
+  class Disconnected_ extends UniffiError implements Disconnected__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "SshError";
+    readonly tag = SshError_Tags.Disconnected;
+    constructor() {
+      super("SshError", "Disconnected");
+    }
+
+    static new(): Disconnected_ {
+      return new Disconnected_();
+    }
+
+    static instanceOf(obj: any): obj is Disconnected_ {
+      return obj.tag === SshError_Tags.Disconnected;
+    }
+    static hasInner(obj: any): obj is Disconnected_ {
+      return false;
+    }
+  }
+
+  type UnsupportedKeyType__interface = {
+    tag: SshError_Tags.UnsupportedKeyType;
+  };
+  class UnsupportedKeyType_
+    extends UniffiError
+    implements UnsupportedKeyType__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "SshError";
+    readonly tag = SshError_Tags.UnsupportedKeyType;
+    constructor() {
+      super("SshError", "UnsupportedKeyType");
+    }
+
+    static new(): UnsupportedKeyType_ {
+      return new UnsupportedKeyType_();
+    }
+
+    static instanceOf(obj: any): obj is UnsupportedKeyType_ {
+      return obj.tag === SshError_Tags.UnsupportedKeyType;
+    }
+    static hasInner(obj: any): obj is UnsupportedKeyType_ {
+      return false;
+    }
+  }
+
+  type Auth__interface = {
+    tag: SshError_Tags.Auth;
+    inner: Readonly<[string]>;
+  };
+  class Auth_ extends UniffiError implements Auth__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "SshError";
+    readonly tag = SshError_Tags.Auth;
+    readonly inner: Readonly<[string]>;
+    constructor(v0: string) {
+      super("SshError", "Auth");
+
+      this.inner = Object.freeze([v0]);
+    }
+    static new(v0: string): Auth_ {
+      return new Auth_(v0);
+    }
+
+    static instanceOf(obj: any): obj is Auth_ {
+      return obj.tag === SshError_Tags.Auth;
+    }
+    static hasInner(obj: any): obj is Auth_ {
+      return Auth_.instanceOf(obj);
+    }
+
+    static getInner(obj: Auth_): Readonly<[string]> {
+      return obj.inner;
+    }
+  }
+
+  type ShellAlreadyRunning__interface = {
+    tag: SshError_Tags.ShellAlreadyRunning;
+  };
+  class ShellAlreadyRunning_
+    extends UniffiError
+    implements ShellAlreadyRunning__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "SshError";
+    readonly tag = SshError_Tags.ShellAlreadyRunning;
+    constructor() {
+      super("SshError", "ShellAlreadyRunning");
+    }
+
+    static new(): ShellAlreadyRunning_ {
+      return new ShellAlreadyRunning_();
+    }
+
+    static instanceOf(obj: any): obj is ShellAlreadyRunning_ {
+      return obj.tag === SshError_Tags.ShellAlreadyRunning;
+    }
+    static hasInner(obj: any): obj is ShellAlreadyRunning_ {
+      return false;
+    }
+  }
+
+  type HostKeyRejected__interface = {
+    tag: SshError_Tags.HostKeyRejected;
+  };
+  class HostKeyRejected_
+    extends UniffiError
+    implements HostKeyRejected__interface
+  {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "SshError";
+    readonly tag = SshError_Tags.HostKeyRejected;
+    constructor() {
+      super("SshError", "HostKeyRejected");
+    }
+
+    static new(): HostKeyRejected_ {
+      return new HostKeyRejected_();
+    }
+
+    static instanceOf(obj: any): obj is HostKeyRejected_ {
+      return obj.tag === SshError_Tags.HostKeyRejected;
+    }
+    static hasInner(obj: any): obj is HostKeyRejected_ {
+      return false;
+    }
+  }
+
+  type NotFound__interface = {
+    tag: SshError_Tags.NotFound;
+    inner: Readonly<[string]>;
+  };
+  class NotFound_ extends UniffiError implements NotFound__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "SshError";
+    readonly tag = SshError_Tags.NotFound;
+    readonly inner: Readonly<[string]>;
+    constructor(v0: string) {
+      super("SshError", "NotFound");
+
+      this.inner = Object.freeze([v0]);
+    }
+    static new(v0: string): NotFound_ {
+      return new NotFound_(v0);
+    }
+
+    static instanceOf(obj: any): obj is NotFound_ {
+      return obj.tag === SshError_Tags.NotFound;
+    }
+    static hasInner(obj: any): obj is NotFound_ {
+      return NotFound_.instanceOf(obj);
+    }
+
+    static getInner(obj: NotFound_): Readonly<[string]> {
+      return obj.inner;
+    }
+  }
+
+  type Ssh__interface = {
+    tag: SshError_Tags.Ssh;
+    inner: Readonly<[string]>;
+  };
+  class Ssh_ extends UniffiError implements Ssh__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "SshError";
+    readonly tag = SshError_Tags.Ssh;
+    readonly inner: Readonly<[string]>;
+    constructor(v0: string) {
+      super("SshError", "Ssh");
+
+      this.inner = Object.freeze([v0]);
+    }
+    static new(v0: string): Ssh_ {
+      return new Ssh_(v0);
+    }
+
+    static instanceOf(obj: any): obj is Ssh_ {
+      return obj.tag === SshError_Tags.Ssh;
+    }
+    static hasInner(obj: any): obj is Ssh_ {
+      return Ssh_.instanceOf(obj);
+    }
+
+    static getInner(obj: Ssh_): Readonly<[string]> {
+      return obj.inner;
+    }
+  }
+
+  type Keys__interface = {
+    tag: SshError_Tags.Keys;
+    inner: Readonly<[string]>;
+  };
+  class Keys_ extends UniffiError implements Keys__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    readonly [uniffiTypeNameSymbol] = "SshError";
+    readonly tag = SshError_Tags.Keys;
+    readonly inner: Readonly<[string]>;
+    constructor(v0: string) {
+      super("SshError", "Keys");
+
+      this.inner = Object.freeze([v0]);
+    }
+    static new(v0: string): Keys_ {
+      return new Keys_(v0);
+    }
+
+    static instanceOf(obj: any): obj is Keys_ {
+      return obj.tag === SshError_Tags.Keys;
+    }
+    static hasInner(obj: any): obj is Keys_ {
+      return Keys_.instanceOf(obj);
+    }
+
+    static getInner(obj: Keys_): Readonly<[string]> {
+      return obj.inner;
+    }
+  }
+
+  function instanceOf(obj: any): obj is SshError {
+    return obj[uniffiTypeNameSymbol] === "SshError";
+  }
+
+  return Object.freeze({
+    instanceOf,
+    Disconnected: Disconnected_,
+    UnsupportedKeyType: UnsupportedKeyType_,
+    Auth: Auth_,
+    ShellAlreadyRunning: ShellAlreadyRunning_,
+    HostKeyRejected: HostKeyRejected_,
+    NotFound: NotFound_,
+    Ssh: Ssh_,
+    Keys: Keys_,
+  });
+})();
+export type SshError = InstanceType<
+  (typeof SshError)[
+    | "Disconnected"
+    | "UnsupportedKeyType"
+    | "Auth"
+    | "ShellAlreadyRunning"
+    | "HostKeyRejected"
+    | "NotFound"
+    | "Ssh"
+    | "Keys"]
+>;
+
+// FfiConverter for enum SshError
+const FfiConverterTypeSshError = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  type TypeName = SshError;
+  class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
+    read(from: RustBuffer): TypeName {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new SshError.Disconnected();
+        case 2:
+          return new SshError.UnsupportedKeyType();
+        case 3:
+          return new SshError.Auth(FfiConverterString.read(from));
+        case 4:
+          return new SshError.ShellAlreadyRunning();
+        case 5:
+          return new SshError.HostKeyRejected();
+        case 6:
+          return new SshError.NotFound(FfiConverterString.read(from));
+        case 7:
+          return new SshError.Ssh(FfiConverterString.read(from));
+        case 8:
+          return new SshError.Keys(FfiConverterString.read(from));
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value: TypeName, into: RustBuffer): void {
+      switch (value.tag) {
+        case SshError_Tags.Disconnected: {
+          ordinalConverter.write(1, into);
+          return;
+        }
+        case SshError_Tags.UnsupportedKeyType: {
+          ordinalConverter.write(2, into);
+          return;
+        }
+        case SshError_Tags.Auth: {
+          ordinalConverter.write(3, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner[0], into);
+          return;
+        }
+        case SshError_Tags.ShellAlreadyRunning: {
+          ordinalConverter.write(4, into);
+          return;
+        }
+        case SshError_Tags.HostKeyRejected: {
+          ordinalConverter.write(5, into);
+          return;
+        }
+        case SshError_Tags.NotFound: {
+          ordinalConverter.write(6, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner[0], into);
+          return;
+        }
+        case SshError_Tags.Ssh: {
+          ordinalConverter.write(7, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner[0], into);
+          return;
+        }
+        case SshError_Tags.Keys: {
+          ordinalConverter.write(8, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner[0], into);
+          return;
+        }
+        default:
+          // Throwing from here means that SshError_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value: TypeName): number {
+      switch (value.tag) {
+        case SshError_Tags.Disconnected: {
+          return ordinalConverter.allocationSize(1);
+        }
+        case SshError_Tags.UnsupportedKeyType: {
+          return ordinalConverter.allocationSize(2);
+        }
+        case SshError_Tags.Auth: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(3);
+          size += FfiConverterString.allocationSize(inner[0]);
+          return size;
+        }
+        case SshError_Tags.ShellAlreadyRunning: {
+          return ordinalConverter.allocationSize(4);
+        }
+        case SshError_Tags.HostKeyRejected: {
+          return ordinalConverter.allocationSize(5);
+        }
+        case SshError_Tags.NotFound: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(6);
+          size += FfiConverterString.allocationSize(inner[0]);
+          return size;
+        }
+        case SshError_Tags.Ssh: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(7);
+          size += FfiConverterString.allocationSize(inner[0]);
+          return size;
+        }
+        case SshError_Tags.Keys: {
+          const inner = value.inner;
+          let size = ordinalConverter.allocationSize(8);
+          size += FfiConverterString.allocationSize(inner[0]);
+          return size;
+        }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * JS implements this to receive the low-frequency event stream (§10 event plane).
+ */
+export interface FresshEventListener {
+  onEvent(event: FresshEvent): void;
+}
+
+/**
+ * JS implements this to receive the low-frequency event stream (§10 event plane).
+ */
+export class FresshEventListenerImpl
+  extends UniffiAbstractObject
+  implements FresshEventListener
+{
+  readonly [uniffiTypeNameSymbol] = "FresshEventListenerImpl";
+  readonly [destructorGuardSymbol]: UniffiGcObject;
+  readonly [pointerLiteralSymbol]: UniffiHandle;
+  // No primary constructor declared for this class.
+  private constructor(pointer: UniffiHandle) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] =
+      uniffiTypeFresshEventListenerImplObjectFactory.bless(pointer);
+  }
+
+  onEvent(event: FresshEvent): void {
+    uniffiCaller.rustCall(
+      /*caller:*/ (callStatus) => {
+        nativeModule().ubrn_uniffi_shim_uniffi_fn_method_fressheventlistener_on_event(
+          uniffiTypeFresshEventListenerImplObjectFactory.clonePointer(this),
+          FfiConverterTypeFresshEvent.lower(
+            event,
+            nativeModule().rustbuffer_alloc
+          ),
+          callStatus
+        );
+      },
+      /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)
+    );
+  }
+
+  uniffiDestroy(): void {
+    const ptr = (this as any)[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer =
+        uniffiTypeFresshEventListenerImplObjectFactory.pointer(this);
+      uniffiTypeFresshEventListenerImplObjectFactory.freePointer(pointer);
+      uniffiTypeFresshEventListenerImplObjectFactory.unbless(ptr);
+      delete (this as any)[destructorGuardSymbol];
+    }
+  }
+
+  static instanceOf(obj_: any): obj_ is FresshEventListenerImpl {
+    return uniffiTypeFresshEventListenerImplObjectFactory.isConcreteType(obj_);
+  }
+}
+
+const uniffiTypeFresshEventListenerImplObjectFactory: UniffiObjectFactory<FresshEventListener> =
+  (() => {
+    return {
+      create(pointer: UniffiHandle): FresshEventListener {
+        const instance = Object.create(FresshEventListenerImpl.prototype);
+        instance[pointerLiteralSymbol] = pointer;
+        instance[destructorGuardSymbol] = this.bless(pointer);
+        instance[uniffiTypeNameSymbol] = "FresshEventListenerImpl";
+        return instance;
+      },
+
+      bless(p: UniffiHandle): UniffiGcObject {
+        return uniffiCaller.rustCall(
+          /*caller:*/ (status) =>
+            nativeModule().ubrn_uniffi_internal_fn_method_fressheventlistener_ffi__bless_pointer(
+              p,
+              status
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      unbless(ptr_: UniffiGcObject) {
+        ptr_.markDestroyed();
+      },
+
+      pointer(obj_: FresshEventListener): UniffiHandle {
+        if ((obj_ as any)[destructorGuardSymbol] === undefined) {
+          throw new UniffiInternalError.UnexpectedNullPointer();
+        }
+        return (obj_ as any)[pointerLiteralSymbol];
+      },
+
+      clonePointer(obj_: FresshEventListener): UniffiHandle {
+        const pointer = this.pointer(obj_);
+        return uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_shim_uniffi_fn_clone_fressheventlistener(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      freePointer(pointer: UniffiHandle): void {
+        uniffiCaller.rustCall(
+          /*caller:*/ (callStatus) =>
+            nativeModule().ubrn_uniffi_shim_uniffi_fn_free_fressheventlistener(
+              pointer,
+              callStatus
+            ),
+          /*liftString:*/ FfiConverterString.lift
+        );
+      },
+
+      isConcreteType(obj_: any): obj_ is FresshEventListener {
+        return (
+          obj_[destructorGuardSymbol] &&
+          obj_[uniffiTypeNameSymbol] === "FresshEventListenerImpl"
+        );
+      },
+    };
+  })();
+const FfiConverterTypeFresshEventListener = new FfiConverterObjectWithCallbacks(
+  uniffiTypeFresshEventListenerImplObjectFactory
+);
+
+// Add a vtable for the callbacks that go in FresshEventListener.
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceFresshEventListener: {
+  vtable: any;
+  register: () => void;
+} = {
+  // Create the VTable using a series of closures.
+  // ts automatically converts these into C callback functions.
+  vtable: {
+    on_event: (uniffiHandle: bigint, event: Uint8Array) => {
+      const uniffiMakeCall = (): void => {
+        const jsCallback =
+          FfiConverterTypeFresshEventListener.lift(uniffiHandle);
+        return jsCallback.onEvent(FfiConverterTypeFresshEvent.lift(event));
+      };
+      const uniffiResult = UniffiResult.ready<void>();
+      const uniffiHandleSuccess = (obj: any) => {};
+      const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCall(
+        /*makeCall:*/ uniffiMakeCall,
+        /*handleSuccess:*/ uniffiHandleSuccess,
+        /*handleError:*/ uniffiHandleError,
+        /*lowerString:*/ FfiConverterString.lower.bind(FfiConverterString),
+        /*alloc:*/ nativeModule().rustbuffer_alloc
+      );
+      return uniffiResult;
+    },
+    uniffi_free: (uniffiHandle: UniffiHandle): void => {
+      // this will throw a stale handle error if the handle isn't found.
+      FfiConverterTypeFresshEventListener.drop(uniffiHandle);
+    },
+    uniffi_clone: (uniffiHandle: UniffiHandle): UniffiHandle => {
+      return FfiConverterTypeFresshEventListener.clone(uniffiHandle);
+    },
+  },
+  register: () => {
+    nativeModule().ubrn_uniffi_shim_uniffi_fn_init_callback_vtable_fressheventlistener(
+      uniffiCallbackInterfaceFresshEventListener.vtable
+    );
+  },
+};
+
+// FfiConverter for number | undefined
+const FfiConverterOptionalInt32 = new FfiConverterOptional(FfiConverterInt32);
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+// FfiConverter for boolean | undefined
+const FfiConverterOptionalBoolean = new FfiConverterOptional(FfiConverterBool);
+
+// FfiConverter for bigint | undefined
+const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+  // Get the bindings contract version from our ComponentInterface
+  const bindingsContractVersion = 30;
+  // Get the scaffolding contract version by calling the into the dylib
+  const scaffoldingContractVersion =
+    nativeModule().ubrn_ffi_shim_uniffi_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(
+      scaffoldingContractVersion,
+      bindingsContractVersion
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_close_preview() !==
+    6557
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_close_preview"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_close_shell() !== 65197
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_close_shell"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_connect() !== 61665
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_connect"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_create_preview() !==
+    11782
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_create_preview"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_disconnect() !== 57410
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_disconnect"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_generate_key_pair() !==
+    45777
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_generate_key_pair"
+    );
+  }
+  if (nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_resize() !== 49250) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_resize"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_respond_to_host_key() !==
+    36974
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_respond_to_host_key"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_run_command() !== 27618
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_run_command"
+    );
+  }
+  if (nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_scroll() !== 59613) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_scroll"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_selection_clear() !==
+    34920
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_selection_clear"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_selection_start() !==
+    35689
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_selection_start"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_selection_text() !==
+    36953
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_selection_text"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_selection_update() !==
+    35856
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_selection_update"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_send_data() !== 45530
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_send_data"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_set_event_listener() !==
+    9714
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_set_event_listener"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_start_shell() !== 23755
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_start_shell"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_func_validate_private_key() !==
+    19734
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_func_validate_private_key"
+    );
+  }
+  if (
+    nativeModule().ubrn_uniffi_shim_uniffi_checksum_method_fressheventlistener_on_event() !==
+    36275
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_shim_uniffi_checksum_method_fressheventlistener_on_event"
+    );
+  }
+
+  uniffiCallbackInterfaceFresshEventListener.register();
+}
+
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeCommandResult,
+    FfiConverterTypeConnectionDetails,
+    FfiConverterTypeFresshEvent,
+    FfiConverterTypeFresshEventListener,
+    FfiConverterTypeKeyType,
+    FfiConverterTypeSecurity,
+    FfiConverterTypeSelectionKind,
+    FfiConverterTypeServerPublicKeyInfo,
+    FfiConverterTypeShellOptions,
+    FfiConverterTypeSshConnectionProgressEvent,
+    FfiConverterTypeSshError,
+    FfiConverterTypeTerminalType,
+  },
+});