green-screen-react 0.4.0 → 1.0.1

package/README.md

@@ -1,76 +1,31 @@
-# GREEN SCREEN REACT (EMULATOR FOR WEB)
+# green-screen-react
 
-Multi-protocol legacy terminal emulator for React. Connects to **TN5250** (IBM i / AS/400), **TN3270** (z/OS mainframe), **VT220** (OpenVMS, Unix), and **HP 6530** (NonStop) hosts.
+Multi-protocol legacy terminal React component. Connects to **TN5250** (IBM i / AS/400), **TN3270** (z/OS mainframe), **VT220** (OpenVMS, Unix), and **HP 6530** (NonStop) hosts.
 
-## Features
+[**Live Preview**](https://visionbridge-solutions.github.io/green-screen-react/)
 
-- **Multi-protocol** — TN5250, TN3270, VT220, HP 6530
-- **Real-time WebSocket** — instant screen updates
-- Protocol-specific color conventions and screen dimensions
-- Keyboard input: text, function keys (F1-F24), tab, arrow keys
-- Field-aware rendering with input field underlines
-- Typing animation with correction detection
-- Auto-reconnect with exponential backoff
-- Fully themeable via CSS custom properties
-- Zero runtime dependencies (peer deps: React 18+)
-- Togglable inline sign-in form (host, credentials, protocol picker)
-- Pluggable adapter interface for any backend
-- Mock mode for instant evaluation without a real host
+## Install
 
-## How It Works
-
-Browsers cannot open raw TCP sockets to telnet hosts. You need a backend that bridges WebSocket to TCP. Choose one:
-
-**Option A — Run locally (development):**
-```
-  Your React App          green-screen-proxy           Legacy Host
-┌──────────────┐        ┌──────────────────┐        ┌──────────────┐
-│  <GreenScreen│  WS    │   Node.js proxy  │  TCP   │  IBM i       │
-│   Terminal/> │◄──────►│   localhost:3001  │◄──────►│  Mainframe   │
-│              │        │                  │        │  VMS / etc.  │
-└──────────────┘        └──────────────────┘        └──────────────┘
-  npm install             npx green-screen-proxy
-  green-screen-react
-```
-
-**Option B — Deploy to Cloudflare (production):**
-```
-  Your React App          Cloudflare Worker            Legacy Host
-┌──────────────┐        ┌──────────────────┐        ┌──────────────┐
-│  <GreenScreen│  WS    │  Durable Object  │  TCP   │  IBM i       │
-│   Terminal/> │◄──────►│  holds TCP conn  │◄──────►│  Mainframe   │
-│              │        │                  │        │  VMS / etc.  │
-└──────────────┘        └──────────────────┘        └──────────────┘
-  npm install             npx green-screen-proxy deploy
-  green-screen-react
+```bash
+npm install green-screen-react green-screen-proxy
 ```
 
-| | Node.js Proxy | Cloudflare Worker |
-|---|---|---|
-| Run with | `npx green-screen-proxy` | `npx green-screen-proxy deploy` |
-| Transport | WebSocket (real-time) | WebSocket (real-time) |
-| Best for | Local dev, self-hosted infra | Production, static sites |
-| Cost | Free (your server) | Free (Cloudflare free tier) |
-
-Both use the same WebSocket protocol, so `WebSocketAdapter` works with either.
-
 ## Quick Start
 
-**Step 1 — Install the component:**
+Start the proxy (separate terminal):
 
 ```bash
-npm install green-screen-react
+npx green-screen-proxy
 ```
 
-**Step 2 — Start the proxy** (in a separate terminal):
+Or start it programmatically from your app:
 
-```bash
-npx green-screen-proxy --mock
+```typescript
+import { createProxy } from 'green-screen-proxy';
+await createProxy({ port: 3001 });
 ```
 
-This starts the proxy on `http://localhost:3001` with mock screens — no real host needed to try it out.
-
-**Step 3 — Render the terminal:**
+Render the component:
 
 ```tsx
 import { GreenScreenTerminal } from 'green-screen-react';
@@ -81,77 +36,7 @@ function App() {
 }
 ```
 
-That's it — the component connects to `localhost:3001` automatically. Remove `--mock` and use the inline sign-in form to connect to a real host.
-
-## Production Deployment (Cloudflare Worker)
-
-Deploy a serverless backend with one command — no server to manage:
-
-```bash
-npx green-screen-proxy deploy
-```
-
-This will:
-1. Install Wrangler (Cloudflare CLI) if not present
-2. Log you in to Cloudflare if needed
-3. Deploy the worker and print the URL
-4. Save the URL to `.env.local` (auto-detects Vite, Next.js, CRA)
-
-Then use it in your app:
-
-```tsx
-import { GreenScreenTerminal, WebSocketAdapter } from 'green-screen-react';
-import 'green-screen-react/styles.css';
-
-// Reads from VITE_GREEN_SCREEN_URL / NEXT_PUBLIC_GREEN_SCREEN_URL / REACT_APP_GREEN_SCREEN_URL
-const adapter = new WebSocketAdapter({
-  workerUrl: import.meta.env.VITE_GREEN_SCREEN_URL
-});
-
-<GreenScreenTerminal adapter={adapter} />
-```
-
-If no `workerUrl` is provided, the adapter defaults to `http://localhost:3001` (the local proxy).
-
-### Deploy options
-
-```bash
-npx green-screen-proxy deploy                          # Default settings
-npx green-screen-proxy deploy --name my-terminal       # Custom worker name
-npx green-screen-proxy deploy --origins https://myapp.com  # Lock CORS to your domain
-```
-
-User-deployed workers have no restrictions. The shared demo worker (GitHub Pages) has rate limiting and SSRF protection.
-
-## Proxy Server
-
-The Node.js proxy is ideal for local development and self-hosted environments.
-
-```bash
-npx green-screen-proxy              # Start on port 3001
-npx green-screen-proxy --mock       # Mock mode (no real host needed)
-npx green-screen-proxy --port 8080  # Custom port
-PORT=8080 npx green-screen-proxy    # Port via environment variable
-```
-
-If you prefer to install it:
-
-```bash
-npm install -g green-screen-proxy
-green-screen-proxy
-```
-
-### Connecting to a real host
-
-Without `--mock`, the proxy opens real TCP connections. The sign-in form in the terminal collects host, port, protocol, and credentials — the proxy handles the rest.
-
-Example: connecting to the public IBM i system at `pub400.com`:
-
-```tsx
-<GreenScreenTerminal defaultProtocol="tn5250" />
-```
-
-Enter `pub400.com` as the host in the sign-in form. The component connects to the local proxy automatically.
+Connects to `localhost:3001` automatically. Use the sign-in form to connect to a real host.
 
 ## Adapters
 
@@ -162,18 +47,18 @@ Real-time bidirectional WebSocket. Works with both the Node.js proxy and the Clo
 ```tsx
 import { WebSocketAdapter } from 'green-screen-react';
 
-// Local proxy
+// Local proxy (default)
 const adapter = new WebSocketAdapter({ workerUrl: 'http://localhost:3001' });
 
 // Cloudflare Worker
 const adapter = new WebSocketAdapter({
   workerUrl: 'https://green-screen-worker.your-subdomain.workers.dev'
 });
-```
 
-Screen updates are pushed instantly — no polling delay.
+<GreenScreenTerminal adapter={adapter} />
+```
 
-### RestAdapter (HTTP polling)
+### RestAdapter
 
 For backends that expose a REST API:
 
@@ -186,133 +71,46 @@ const adapter = new RestAdapter({
 });
 ```
 
-Maps adapter methods to HTTP endpoints (relative to `baseUrl`):
-
-| Method | Path | Request Body |
-|--------|------|-------------|
-| GET | `/screen` | - |
-| GET | `/status` | - |
-| POST | `/connect` | `{ host, port, protocol }` |
-| POST | `/send-text` | `{ text }` |
-| POST | `/send-key` | `{ key }` |
-| POST | `/disconnect` | - |
-| POST | `/reconnect` | - |
-
-### Custom Adapters
+### Custom Adapter
 
 Implement `TerminalAdapter` to connect to any backend:
 
 ```typescript
-import type { TerminalAdapter, ScreenData, ConnectionStatus, SendResult, ConnectConfig } from 'green-screen-react';
+import type { TerminalAdapter } from 'green-screen-react';
 
 class MyAdapter implements TerminalAdapter {
-  async getScreen(): Promise<ScreenData | null> { /* ... */ }
-  async getStatus(): Promise<ConnectionStatus> { /* ... */ }
-  async sendText(text: string): Promise<SendResult> { /* ... */ }
-  async sendKey(key: string): Promise<SendResult> { /* ... */ }
-  async connect(config?: ConnectConfig): Promise<SendResult> { /* ... */ }
-  async disconnect(): Promise<SendResult> { /* ... */ }
-  async reconnect(): Promise<SendResult> { /* ... */ }
+  async getScreen() { /* ... */ }
+  async getStatus() { /* ... */ }
+  async sendText(text: string) { /* ... */ }
+  async sendKey(key: string) { /* ... */ }
+  async connect(config?) { /* ... */ }
+  async disconnect() { /* ... */ }
+  async reconnect() { /* ... */ }
 }
 ```
 
-## Component Usage
-
-### Minimal (inline sign-in)
-
-```tsx
-import { GreenScreenTerminal } from 'green-screen-react';
-import 'green-screen-react/styles.css';
-
-// Connects to localhost:3001 by default. Sign-in form collects host and credentials.
-<GreenScreenTerminal />
-```
-
-### Switching protocols
-
-```tsx
-<GreenScreenTerminal adapter={adapter} protocol="tn3270" />
-<GreenScreenTerminal adapter={adapter} protocol="vt" />
-<GreenScreenTerminal adapter={adapter} protocol="hp6530" />
-```
-
-### Inline Sign-In
-
-The sign-in form appears by default when disconnected. It collects host, port, protocol, and credentials.
-
-```tsx
-// Disable the form (use when you manage connections yourself)
-<GreenScreenTerminal adapter={adapter} inlineSignIn={false} />
-
-// Pre-select a protocol
-<GreenScreenTerminal
-  adapter={adapter}
-  defaultProtocol="tn3270"
-  onSignIn={(config) => console.log('Connecting to', config.host)}
-/>
-```
-
 ## Props
 
 | Prop | Type | Default | Description |
 |------|------|---------|-------------|
-| `adapter` | `TerminalAdapter` | - | Backend communication adapter |
-| `baseUrl` | `string` | - | Shorthand — auto-creates a RestAdapter |
+| `adapter` | `TerminalAdapter` | auto | Backend adapter |
 | `protocol` | `'tn5250' \| 'tn3270' \| 'vt' \| 'hp6530'` | `'tn5250'` | Terminal protocol |
-| `protocolProfile` | `ProtocolProfile` | - | Custom protocol profile (overrides `protocol`) |
-| `screenData` | `ScreenData` | - | Direct screen data injection (bypasses polling) |
-| `connectionStatus` | `ConnectionStatus` | - | Direct status injection |
 | `inlineSignIn` | `boolean` | `true` | Show sign-in form when disconnected |
-| `defaultProtocol` | `TerminalProtocol` | `'tn5250'` | Pre-selected protocol in sign-in form |
-| `onSignIn` | `(config) => void` | - | Sign-in submit callback |
+| `defaultProtocol` | `TerminalProtocol` | `'tn5250'` | Pre-selected protocol in sign-in |
 | `readOnly` | `boolean` | `false` | Disable keyboard input |
-| `pollInterval` | `number` | `2000` | Screen polling interval in ms (0 to disable) |
+| `pollInterval` | `number` | `2000` | Screen polling interval (ms) |
 | `autoReconnect` | `boolean` | `true` | Auto-reconnect on disconnect |
-| `maxReconnectAttempts` | `number` | `5` | Max reconnect attempts |
 | `embedded` | `boolean` | `false` | Compact embedded mode |
 | `showHeader` | `boolean` | `true` | Show header bar |
 | `typingAnimation` | `boolean` | `true` | Enable typing animation |
-| `bootLoader` | `ReactNode \| false` | default | Custom boot loader or `false` to disable |
-| `headerRight` | `ReactNode` | - | Content for right side of header |
-| `overlay` | `ReactNode` | - | Custom overlay content |
-| `onNotification` | `(msg, type) => void` | - | Notification callback |
+| `bootLoader` | `ReactNode \| false` | default | Custom boot loader |
+| `onSignIn` | `(config) => void` | - | Sign-in callback |
 | `onScreenChange` | `(screen) => void` | - | Screen change callback |
-| `className` | `string` | - | Additional CSS class |
+| `className` | `string` | - | CSS class |
 | `style` | `CSSProperties` | - | Inline styles |
 
-## Key Types
-
-```typescript
-interface ScreenData {
-  content: string;       // Newline-separated text (24 lines of 80 chars)
-  cursor_row: number;    // 0-based cursor row
-  cursor_col: number;    // 0-based cursor column
-  rows?: number;         // Terminal rows (default 24)
-  cols?: number;         // Terminal columns (default 80)
-  fields?: Field[];      // Input/protected field definitions
-}
-
-interface ConnectionStatus {
-  connected: boolean;
-  status: 'disconnected' | 'connecting' | 'connected' | 'authenticated' | 'error';
-  protocol?: TerminalProtocol;
-  host?: string;
-  error?: string;
-}
-
-interface Field {
-  row: number;           // 0-based row
-  col: number;           // 0-based column
-  length: number;        // Field length in characters
-  is_input: boolean;     // Accepts user input
-  is_protected: boolean; // Read-only
-}
-```
-
 ## Theming
 
-Override CSS custom properties to customize the look:
-
 ```css
 :root {
   --terminal-green: #10b981;
@@ -326,30 +124,6 @@ Override CSS custom properties to customize the look:
 }
 ```
 
-## Exports
-
-### Adapters
-
-- `WebSocketAdapter` — Real-time WebSocket (works with proxy and worker)
-- `RestAdapter` — HTTP polling
-
-### Hooks
-
-- `useTerminalConnection(adapter)` — Connection lifecycle
-- `useTerminalScreen(adapter, interval, enabled)` — Screen polling
-- `useTerminalInput(adapter)` — Send text/key operations
-- `useTypingAnimation(content, enabled, budgetMs)` — Typing animation
-
-### Protocol Profiles
-
-- `getProtocolProfile(protocol)` — Get built-in profile by name
-- `tn5250Profile`, `tn3270Profile`, `vtProfile`, `hp6530Profile`
-
-### Utilities
-
-- `positionToRowCol(content, position)` — Convert linear position to row/col
-- `isFieldEntry(prev, next)` — Detect field entry vs screen transition
-
 ## License
 
 MIT

package/dist/index.d.mts

@@ -1,10 +1,8 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React from 'react';
+import { ScreenData, ConnectionStatus, ConnectConfig, ProtocolType } from 'green-screen-types';
+export { ConnectConfig, ConnectionStatus, Field, ScreenData, ProtocolType as TerminalProtocol } from 'green-screen-types';
 
-/**
- * Supported terminal protocol types.
- */
-type TerminalProtocol = 'tn5250' | 'tn3270' | 'vt' | 'hp6530';
 /**
  * Protocol-specific color/rendering conventions.
  */
@@ -22,7 +20,7 @@ interface ProtocolColorProfile {
  */
 interface ProtocolProfile {
     /** Protocol identifier */
-    protocol: TerminalProtocol;
+    protocol: string;
     /** Human-readable name */
     displayName: string;
     /** Default terminal dimensions */
@@ -35,65 +33,6 @@ interface ProtocolProfile {
     /** Boot loader default text */
     bootText: string;
 }
-/**
- * Field definition from the terminal data stream.
- * Describes an input or protected field on the terminal screen.
- */
-interface Field {
-    /** 0-based row index */
-    row: number;
-    /** 0-based column index */
-    col: number;
-    /** Field length in characters */
-    length: number;
-    /** Whether the field accepts user input */
-    is_input: boolean;
-    /** Whether the field is protected (read-only) */
-    is_protected: boolean;
-    /** Whether the field is displayed with high intensity (bright/white) */
-    is_highlighted?: boolean;
-    /** Whether the field is displayed in reverse video */
-    is_reverse?: boolean;
-}
-/**
- * Screen data returned by the adapter.
- * Represents the current state of the terminal screen.
- */
-interface ScreenData {
-    /** Screen content as newline-separated text (e.g. 24 lines of 80 chars) */
-    content: string;
-    /** 0-based cursor row */
-    cursor_row: number;
-    /** 0-based cursor column */
-    cursor_col: number;
-    /** Number of rows (default 24) */
-    rows?: number;
-    /** Number of columns (default 80) */
-    cols?: number;
-    /** Field definitions on the current screen */
-    fields?: Field[];
-    /** Unique identifier for the current screen state */
-    screen_signature?: string;
-    /** ISO timestamp of when this screen was captured */
-    timestamp?: string;
-}
-/**
- * Connection status information.
- */
-interface ConnectionStatus {
-    /** Whether a TCP connection is established */
-    connected: boolean;
-    /** Current connection state */
-    status: 'disconnected' | 'connecting' | 'connected' | 'authenticated' | 'error';
-    /** Terminal protocol in use */
-    protocol?: TerminalProtocol;
-    /** Host address */
-    host?: string;
-    /** Authenticated username */
-    username?: string;
-    /** Error message if status is 'error' */
-    error?: string;
-}
 /**
  * Result from a send operation (text or key).
  */
@@ -133,29 +72,16 @@ interface TerminalAdapter {
     /** Reconnect to the host */
     reconnect(): Promise<SendResult>;
 }
-/**
- * Configuration passed from the inline sign-in form to adapter.connect().
- */
-interface ConnectConfig {
-    /** Target host address */
-    host: string;
-    /** Target port (optional, adapter/server can default per protocol) */
-    port?: number;
-    /** Terminal protocol */
-    protocol: TerminalProtocol;
-    /** Username for authentication */
-    username: string;
-    /** Password for authentication */
-    password: string;
-}
 
 interface GreenScreenTerminalProps {
     /** Adapter for communicating with the terminal backend (optional — auto-created from sign-in form or baseUrl) */
     adapter?: TerminalAdapter;
     /** Base URL for the terminal API — convenience shorthand that auto-creates a RestAdapter */
     baseUrl?: string;
+    /** Worker/proxy WebSocket URL — convenience shorthand that auto-creates a WebSocketAdapter */
+    workerUrl?: string;
     /** Terminal protocol (determines color conventions, header label, etc.) */
-    protocol?: TerminalProtocol;
+    protocol?: ProtocolType;
     /** Custom protocol profile (overrides protocol param) */
     protocolProfile?: ProtocolProfile;
     /** Direct screen data injection (bypasses polling) */
@@ -181,9 +107,13 @@ interface GreenScreenTerminalProps {
     /** Show inline sign-in form when disconnected (default true) */
     inlineSignIn?: boolean;
     /** Default protocol for the sign-in form dropdown (default 'tn5250') */
-    defaultProtocol?: TerminalProtocol;
+    defaultProtocol?: ProtocolType;
     /** Callback when sign-in form is submitted */
     onSignIn?: (config: ConnectConfig) => void;
+    /** Show "press Enter to continue" hint after auto sign-in (for external adapter flows) */
+    autoSignedIn?: boolean;
+    /** Disable auto-focus on the terminal after connecting (default false) */
+    autoFocusDisabled?: boolean;
     /** Custom boot loader element, or false to disable */
     bootLoader?: React.ReactNode | false;
     /** Content for the right side of the header */
@@ -214,7 +144,7 @@ interface GreenScreenTerminalProps {
  *
  * Supports: TN5250 (IBM i), TN3270 (z/OS), VT (OpenVMS/Pick), HP 6530 (NonStop)
  */
-declare function GreenScreenTerminal({ adapter: externalAdapter, baseUrl, protocol, protocolProfile: customProfile, screenData: externalScreenData, connectionStatus: externalStatus, readOnly, pollInterval, autoReconnect: autoReconnectEnabled, maxReconnectAttempts: maxAttempts, embedded, showHeader, typingAnimation, typingBudgetMs, inlineSignIn, defaultProtocol: signInDefaultProtocol, onSignIn, bootLoader, headerRight, overlay, onNotification, onScreenChange, onMinimize, className, style, }: GreenScreenTerminalProps): react_jsx_runtime.JSX.Element;
+declare function GreenScreenTerminal({ adapter: externalAdapter, baseUrl, workerUrl, protocol, protocolProfile: customProfile, screenData: externalScreenData, connectionStatus: externalStatus, readOnly, pollInterval, autoReconnect: autoReconnectEnabled, maxReconnectAttempts: maxAttempts, embedded, showHeader, typingAnimation, typingBudgetMs, inlineSignIn, defaultProtocol: signInDefaultProtocol, onSignIn, autoSignedIn, autoFocusDisabled, bootLoader, headerRight, overlay, onNotification, onScreenChange, onMinimize, className, style, }: GreenScreenTerminalProps): react_jsx_runtime.JSX.Element;
 
 interface TerminalBootLoaderProps {
     /** Text to display during boot animation */
@@ -233,12 +163,12 @@ interface TerminalBootLoaderProps {
 declare function TerminalBootLoader({ brandText, charSpeed, logo, height, }: TerminalBootLoaderProps): react_jsx_runtime.JSX.Element;
 
 interface InlineSignInProps {
-    defaultProtocol: TerminalProtocol;
+    defaultProtocol: ProtocolType;
     loading: boolean;
     error: string | null;
     onConnect: (config: ConnectConfig) => void;
 }
-declare function InlineSignIn({ defaultProtocol, loading, error, onConnect }: InlineSignInProps): react_jsx_runtime.JSX.Element;
+declare function InlineSignIn({ defaultProtocol, loading: externalLoading, error, onConnect }: InlineSignInProps): react_jsx_runtime.JSX.Element;
 
 declare const TerminalIcon: ({ size }: {
     size?: number;
@@ -303,25 +233,38 @@ declare class RestAdapter implements TerminalAdapter {
 }
 
 interface WebSocketAdapterOptions {
-    /** URL of the green-screen proxy or worker. Defaults to http://localhost:3001 */
+    /** URL of the green-screen proxy or worker. Auto-detected from env vars, defaults to http://localhost:3001 */
     workerUrl?: string;
 }
 /**
- * WebSocket adapter that connects to a Cloudflare Worker running green-screen-worker.
- * The Worker holds the TCP connection to the legacy host and relays protocol data.
+ * WebSocket adapter that connects to a green-screen proxy or Cloudflare Worker.
+ * The backend holds the TCP connection to the legacy host and relays protocol data.
  *
  * Unlike RestAdapter (which polls over HTTP), this adapter receives real-time
  * screen updates via WebSocket push.
+ *
+ * workerUrl resolution order:
+ *   1. Explicit `workerUrl` option
+ *   2. VITE_GREEN_SCREEN_URL / VITE_WORKER_URL (Vite)
+ *   3. NEXT_PUBLIC_GREEN_SCREEN_URL (Next.js)
+ *   4. REACT_APP_GREEN_SCREEN_URL (CRA)
+ *   5. http://localhost:3001
  */
 declare class WebSocketAdapter implements TerminalAdapter {
     private workerUrl;
     private ws;
     private screen;
     private status;
-    private pendingResolvers;
+    private pendingScreenResolver;
+    private pendingConnectResolver;
+    private connectingPromise;
     private screenListeners;
     private statusListeners;
+    private _sessionId;
     constructor(options?: WebSocketAdapterOptions);
+    private static detectEnvUrl;
+    /** The proxy-side session ID (available after connect or reattach) */
+    get sessionId(): string | null;
     /** Subscribe to real-time screen updates */
     onScreen(listener: (screen: ScreenData) => void): () => void;
     /** Subscribe to status changes */
@@ -331,9 +274,15 @@ declare class WebSocketAdapter implements TerminalAdapter {
     sendText(text: string): Promise<SendResult>;
     sendKey(key: string): Promise<SendResult>;
     connect(config?: ConnectConfig): Promise<SendResult>;
+    /**
+     * Reattach to an existing proxy session (e.g. after page reload).
+     * The proxy keeps the TCP connection alive; this just reconnects the
+     * WebSocket and receives the current screen.
+     */
+    reattach(sessionId: string): Promise<SendResult>;
     disconnect(): Promise<SendResult>;
     reconnect(): Promise<SendResult>;
-    /** Close the WebSocket without sending disconnect */
+    /** Close the WebSocket without sending disconnect (session stays alive on proxy) */
     dispose(): void;
     private ensureWebSocket;
     private handleMessage;
@@ -416,7 +365,7 @@ declare function useTerminalInput(adapter: TerminalAdapter): {
 /**
  * Get a protocol profile by type. Defaults to TN5250 for backward compatibility.
  */
-declare function getProtocolProfile(protocol?: TerminalProtocol): ProtocolProfile;
+declare function getProtocolProfile(protocol?: ProtocolType): ProtocolProfile;
 
 declare const tn5250Profile: ProtocolProfile;
 
@@ -461,4 +410,4 @@ declare function parseHeaderRow(line: string): {
     colorClass: string;
 }[] | null;
 
-export { AlertTriangleIcon, type ConnectConfig, type ConnectionStatus, type Field, GreenScreenTerminal, type GreenScreenTerminalProps, InlineSignIn, type InlineSignInProps, KeyIcon, MinimizeIcon, type ProtocolColorProfile, type ProtocolProfile, RefreshIcon, RestAdapter, type RestAdapterOptions, type ScreenData, type SendResult, type TerminalAdapter, TerminalBootLoader, type TerminalBootLoaderProps, TerminalIcon, type TerminalProtocol, WebSocketAdapter, type WebSocketAdapterOptions, WifiIcon, WifiOffIcon, getProtocolProfile, getRowColorClass, hp6530Profile, isFieldEntry, parseHeaderRow, positionToRowCol, tn3270Profile, tn5250Profile, useTerminalConnection, useTerminalInput, useTerminalScreen, useTypingAnimation, vtProfile };
+export { AlertTriangleIcon, GreenScreenTerminal, type GreenScreenTerminalProps, InlineSignIn, type InlineSignInProps, KeyIcon, MinimizeIcon, type ProtocolColorProfile, type ProtocolProfile, RefreshIcon, RestAdapter, type RestAdapterOptions, type SendResult, type TerminalAdapter, TerminalBootLoader, type TerminalBootLoaderProps, TerminalIcon, WebSocketAdapter, type WebSocketAdapterOptions, WifiIcon, WifiOffIcon, getProtocolProfile, getRowColorClass, hp6530Profile, isFieldEntry, parseHeaderRow, positionToRowCol, tn3270Profile, tn5250Profile, useTerminalConnection, useTerminalInput, useTerminalScreen, useTypingAnimation, vtProfile };