@slopus/happy-terminal 0.3.0-beta.13

package/dist/observability/daemonContext.d.ts

@@ -0,0 +1,16 @@
+import { type Context, type Logger } from "@steve.kite/stdlib";
+import { type Attributes, type Tracer as OpenTelemetryTracer } from "@opentelemetry/api";
+export type ContextWork<Result> = (ctx: Context) => Result | PromiseLike<Result>;
+/** Adds OpenTelemetry attributes to the stdlib span currently carried by a context. */
+export declare function setSpanAttributes(ctx: Context, attributes: Attributes): void;
+/** Returns the OpenTelemetry trace ID for the span currently carried by a context. */
+export declare function spanTraceId(ctx: Context): string | undefined;
+export declare function withRequestContext<Result>(route: string, logContext: Readonly<Record<string, unknown>>, work: ContextWork<Result>): Promise<Awaited<Result>>;
+/** Runs an intentionally untraced streaming request without creating a named lifetime context. */
+export declare function withUntracedRequestContext<Result>(route: string, logContext: Readonly<Record<string, unknown>>, work: ContextWork<Result>): Promise<Awaited<Result>>;
+export declare function withWorkerContext<Result>(worker: string, work: ContextWork<Result>, logContext?: Readonly<Record<string, unknown>>): Promise<Awaited<Result>>;
+export declare function withConnectionContext<Result>(connection: string, work: ContextWork<Result>, logContext?: Readonly<Record<string, unknown>>): Promise<Awaited<Result>>;
+export declare function withProcessContext<Result>(processName: string, work: ContextWork<Result>, logContext?: Readonly<Record<string, unknown>>): Promise<Awaited<Result>>;
+export declare function withTerminalContext<Result>(terminal: string, work: ContextWork<Result>, logContext?: Readonly<Record<string, unknown>>): Promise<Awaited<Result>>;
+/** Installs logging and tracing on the private application root. */
+export declare function initializeDaemonContext(logger: Logger, tracer?: OpenTelemetryTracer): void;

package/dist/observability/index.d.ts

@@ -0,0 +1 @@
+export { initializeDaemonContext, setSpanAttributes, spanTraceId, withConnectionContext, withProcessContext, withRequestContext, withTerminalContext, withUntracedRequestContext, withWorkerContext, type ContextWork, } from "./daemonContext.js";

package/dist/processes/BoundedOutputBuffer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Retains a stable prefix and suffix while counting the bytes dropped from the
+ * middle. This is the same shape Codex uses for unified exec output.
+ */
+export declare class BoundedOutputBuffer {
+    #private;
+    constructor(maxBytes: number);
+    get totalBytes(): number;
+    get omittedBytes(): number;
+    get retainedBytes(): number;
+    append(chunk: Buffer): void;
+    snapshot(omittedBytes?: number): Buffer;
+    snapshotFromOffset(offset: number): {
+        buffer: Buffer;
+        omittedBytes: number;
+        totalBytes: number;
+    };
+    drain(): BoundedOutputBuffer;
+    clone(): BoundedOutputBuffer;
+}

package/dist/processes/NativeProcessManager.d.ts

@@ -0,0 +1,66 @@
+import type { Context } from "@steve.kite/stdlib";
+import type { ManagedProcessStatus, ProcessKillOptions, ProcessRunOptions, ProcessRunResult, ProcessSnapshot, ProcessStartOptions } from "./types.js";
+export declare class NativeProcessManager {
+    #private;
+    start(ctx: Context, options: ProcessStartOptions): Promise<ManagedProcess>;
+    run(ctx: Context, options: ProcessRunOptions): Promise<ProcessRunResult>;
+    get(id: string): ManagedProcess | undefined;
+    snapshots(): ProcessSnapshot[];
+    activeCount(): number;
+    writeStdin(ctx: Context, id: string, data: string | Uint8Array): Promise<boolean>;
+    kill(ctx: Context, id: string, options?: ProcessKillOptions): Promise<boolean>;
+    /**
+     * Stops running work.
+     *
+     * Detached work — a command the agent deliberately left running in the
+     * background — is spared unless the caller is shutting everything down, in
+     * which case whole process groups go too, including anything that outlived
+     * the shell that launched it.
+     */
+    killAll(ctx: Context, options?: ProcessKillOptions): Promise<void>;
+    /** Process groups that a shutdown would still have to take down. */
+    pendingProcessGroups(): readonly number[];
+    /**
+     * How much running work a shutdown would still find.
+     *
+     * A live command and the group it leads are one thing, so the group of an
+     * active process is not counted twice. What this adds are the groups that
+     * outlived the command that started them: `nohup server &` leaves nothing
+     * running under our watch, but the server is very much still there.
+     */
+    reapableCount(): number;
+}
+export interface ManagedProcessHooks {
+    /** The whole process group is known to be gone. */
+    onGroupTerminated: (processGroupId: number) => void;
+    /** No more output or exit information can arrive. */
+    onSettled: (id: string) => void;
+}
+export declare class ManagedProcess {
+    #private;
+    readonly id: `${string}-${string}-${string}-${string}-${string}`;
+    readonly command: string;
+    readonly cwd: string;
+    readonly pid: number | null;
+    /** The agent left this running on purpose; an interrupted turn spares it. */
+    detached: boolean;
+    private constructor();
+    static start(ctx: Context, options: ProcessStartOptions, hooks: ManagedProcessHooks): Promise<ManagedProcess>;
+    get status(): ManagedProcessStatus;
+    snapshot(): ProcessSnapshot;
+    readOutput(stdoutOffset: number, stderrOffset: number, consume?: boolean): ProcessSnapshot & {
+        stderrDelta: string;
+        stderrDeltaBytes: number;
+        stderrDeltaOmittedBytes: number;
+        stderrOffset: number;
+        stdoutDelta: string;
+        stdoutDeltaBytes: number;
+        stdoutDeltaOmittedBytes: number;
+        stdoutOffset: number;
+    };
+    writeStdin(ctx: Context, data: string | Uint8Array): Promise<boolean>;
+    endStdin(ctx: Context, data?: string | Uint8Array): Promise<void>;
+    interrupt(ctx: Context): Promise<boolean>;
+    kill(ctx: Context, signal?: NodeJS.Signals, options?: ProcessKillOptions): Promise<void>;
+    wait(ctx: Context): Promise<ProcessRunResult>;
+}

package/dist/processes/ProcessGroupReaper.d.ts

@@ -0,0 +1,32 @@
+import type { Context } from "@steve.kite/stdlib";
+/**
+ * Remembers the process groups we started so shutdown can take them down.
+ *
+ * A background command outlives the shell that launched it, so a group has to
+ * stay reapable long after its leader is gone.
+ *
+ * A group is identified by the number the operating system gave it, and that
+ * number is reused once the group is gone. Every group is therefore dropped as
+ * soon as it dies, and checked again immediately before it is signalled, which
+ * narrows the window in which a recycled identifier could be mistaken for ours
+ * to the gap between that check and the signal. Closing it entirely would take
+ * a kernel handle on the group, which the platforms we support do not offer.
+ */
+export declare class ProcessGroupReaper {
+    #private;
+    retain(processGroupId: number): void;
+    release(processGroupId: number): void;
+    /** The groups we would take down right now, for tests and diagnostics. */
+    pending(): readonly number[];
+    /** Asks every surviving group to stop, then forces the ones that did not. */
+    terminateAll(ctx: Context, forceAfterMs: number): Promise<void>;
+}
+/**
+ * Signals a whole process group and nothing else.
+ *
+ * Unlike killing a process tree, there is deliberately no fall back to the bare
+ * identifier: if the group is gone, the number may now belong to an unrelated
+ * process, and signalling it would be someone else's problem.
+ */
+export declare function killProcessGroup(ctx: Context, processGroupId: number, signal: NodeJS.Signals): Promise<void>;
+export declare function isProcessGroupAlive(processGroupId: number): boolean;

package/dist/processes/index.d.ts

@@ -0,0 +1,7 @@
+export { killProcessTree } from "./killProcessTree.js";
+export { isTargetProcessAlive } from "./isTargetProcessAlive.js";
+export { BoundedOutputBuffer } from "./BoundedOutputBuffer.js";
+export { ManagedProcess, NativeProcessManager } from "./NativeProcessManager.js";
+export { resolveSystemShell } from "./resolveSystemShell.js";
+export { waitForProcessExit } from "./waitForProcessExit.js";
+export type { ManagedProcessStatus, ProcessKillOptions, ProcessRunOptions, ProcessRunResult, ProcessSnapshot, ProcessStartOptions, } from "./types.js";

package/dist/processes/isProcessRunning.d.ts

@@ -0,0 +1 @@
+export declare function isProcessRunning(processId: number): Promise<boolean>;

package/dist/processes/isTargetProcessAlive.d.ts

@@ -0,0 +1 @@
+export declare function isTargetProcessAlive(pid: number): boolean;

package/dist/processes/killProcessTree.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from "@steve.kite/stdlib";
+export declare function killProcessTree(ctx: Context, pid: number, signal?: NodeJS.Signals): Promise<void>;

package/dist/processes/resolveSystemShell.d.ts

@@ -0,0 +1 @@
+export declare function resolveSystemShell(environment?: NodeJS.ProcessEnv): string;

package/dist/processes/startProcessTransport.d.ts

@@ -0,0 +1,33 @@
+import type { Context } from "@steve.kite/stdlib";
+import type { ProcessStartOptions } from "./types.js";
+/**
+ * How a running command is talked to.
+ *
+ * Pipes and a pseudo-terminal differ in ways the process bookkeeping should not
+ * have to know about: a terminal merges the two output streams, echoes input,
+ * and reports one exit rather than a separate stream close.
+ */
+export interface ProcessTransport {
+    readonly kind: "pipe" | "pty";
+    readonly pid: number | null;
+    /** Whether stderr arrives separately. A terminal merges it into stdout. */
+    readonly separatesStderr: boolean;
+    endInput(data?: string | Uint8Array): void;
+    onError(listener: (error: Error) => void): void;
+    onExit(listener: (code: number | null, signal: NodeJS.Signals | null) => void): void;
+    onOutputEnd(listener: () => void): void;
+    onStderr(listener: (chunk: Buffer) => void): void;
+    onStdout(listener: (chunk: Buffer) => void): void;
+    /** Releases every listener; the command may still be running. */
+    release(): void;
+    write(data: string | Uint8Array): boolean;
+}
+/**
+ * Discourages terminal-shaped output from a command the model cannot watch.
+ *
+ * A pseudo-terminal invites full-screen redraws, colour, and pagers that wait
+ * for a keypress. None of that survives being read as text, so the environment
+ * asks programs not to produce it in the first place.
+ */
+export declare const NON_INTERACTIVE_TERMINAL_ENVIRONMENT: NodeJS.ProcessEnv;
+export declare function startProcessTransport<Result>(ctx: Context, options: ProcessStartOptions, started: (ctx: Context, transport: ProcessTransport) => Result | PromiseLike<Result>): Promise<Awaited<Result>>;

package/dist/processes/types.d.ts

@@ -0,0 +1,41 @@
+export type ManagedProcessStatus = "running" | "exited" | "killed";
+export interface ProcessStartOptions {
+    args?: readonly string[];
+    command: string;
+    cwd: string;
+    shell?: string;
+    env?: NodeJS.ProcessEnv;
+    maxOutputBytes?: number;
+    /** Run the command under a pseudo-terminal instead of pipes. */
+    tty?: boolean;
+}
+export interface ProcessRunOptions extends ProcessStartOptions {
+    timeoutMs?: number;
+    killGraceMs?: number;
+    signal?: AbortSignal;
+}
+export interface ProcessKillOptions {
+    forceAfterMs?: number;
+    /** Also stop work deliberately left running in the background. */
+    includeDetached?: boolean;
+}
+export interface ProcessSnapshot {
+    id: string;
+    pid: number | null;
+    command: string;
+    cwd: string;
+    status: ManagedProcessStatus;
+    stdout: string;
+    stderr: string;
+    stdoutBytes?: number;
+    stderrBytes?: number;
+    stdoutOmittedBytes?: number;
+    stderrOmittedBytes?: number;
+}
+export interface ProcessRunResult extends ProcessSnapshot {
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    timedOut: boolean;
+    aborted: boolean;
+    killed: boolean;
+}

package/dist/processes/waitForProcessExit.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from "@steve.kite/stdlib";
+export declare function waitForProcessExit(ctx: Context, processId: number, timeoutMs: number): Promise<boolean>;

package/dist/protocol/AppletProtocol.d.ts

@@ -0,0 +1,101 @@
+import { type Static } from "@sinclair/typebox";
+import type { EventId } from "./EventId.js";
+export declare const defaultAppletAllowedScopes: readonly ["everywhere", "project", "workspace", "session"];
+export declare const appletAllowedScopesSchema: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"everywhere">, import("@sinclair/typebox").TLiteral<"project">, import("@sinclair/typebox").TLiteral<"workspace">, import("@sinclair/typebox").TLiteral<"session">]>>;
+export type AppletAllowedScopes = Static<typeof appletAllowedScopesSchema>;
+export declare const appletVersionSchema: import("@sinclair/typebox").TObject<{
+    version: import("@sinclair/typebox").TInteger;
+    changeDescription: import("@sinclair/typebox").TString;
+    createdAt: import("@sinclair/typebox").TNumber;
+}>;
+export type AppletVersion = Static<typeof appletVersionSchema>;
+/**
+ * An applet is created by importing a source folder; no agent writes into the applet data folder
+ * directly. Each import lands in its own version directory (`v1`, `v2`, ...), one version is
+ * current, and Happy Terminal serves the current version's static files with `index.html` as the entry point.
+ */
+export declare const appletSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TString;
+    purpose: import("@sinclair/typebox").TString;
+    allowedScopes: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"everywhere">, import("@sinclair/typebox").TLiteral<"project">, import("@sinclair/typebox").TLiteral<"workspace">, import("@sinclair/typebox").TLiteral<"session">]>>;
+    iconThumbhash: import("@sinclair/typebox").TString;
+    iconUrl: import("@sinclair/typebox").TString;
+    authorSessionId: import("@sinclair/typebox").TString;
+    sourceDescription: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    currentVersion: import("@sinclair/typebox").TInteger;
+    versions: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        version: import("@sinclair/typebox").TInteger;
+        changeDescription: import("@sinclair/typebox").TString;
+        createdAt: import("@sinclair/typebox").TNumber;
+    }>>;
+    createdAt: import("@sinclair/typebox").TNumber;
+    updatedAt: import("@sinclair/typebox").TNumber;
+}>;
+export type Applet = Static<typeof appletSchema>;
+export declare const createAppletRequestSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TString;
+    purpose: import("@sinclair/typebox").TString;
+    allowedScopes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"everywhere">, import("@sinclair/typebox").TLiteral<"project">, import("@sinclair/typebox").TLiteral<"workspace">, import("@sinclair/typebox").TLiteral<"session">]>>>;
+    authorSessionId: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TString;
+    iconPath: import("@sinclair/typebox").TString;
+    sourceDescription: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type CreateAppletRequest = Static<typeof createAppletRequestSchema>;
+export declare const updateAppletRequestSchema: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TString;
+    changeDescription: import("@sinclair/typebox").TString;
+    allowedScopes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"everywhere">, import("@sinclair/typebox").TLiteral<"project">, import("@sinclair/typebox").TLiteral<"workspace">, import("@sinclair/typebox").TLiteral<"session">]>>>;
+}>;
+export type UpdateAppletRequest = Static<typeof updateAppletRequestSchema>;
+export declare const resolveAppletOpenRequestSchema: import("@sinclair/typebox").TObject<{
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    sessionId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    projectId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    workspaceId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type ResolveAppletOpenRequest = Static<typeof resolveAppletOpenRequestSchema>;
+export declare const resolveAppletOpenResponseSchema: import("@sinclair/typebox").TObject<{
+    url: import("@sinclair/typebox").TString;
+}>;
+export type ResolveAppletOpenResponse = Static<typeof resolveAppletOpenResponseSchema>;
+export declare const appletContextSchema: import("@sinclair/typebox").TObject<{
+    applet: import("@sinclair/typebox").TString;
+    version: import("@sinclair/typebox").TInteger;
+    sessionId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    projectId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    workspaceId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type AppletContext = Static<typeof appletContextSchema>;
+export declare const revertAppletRequestSchema: import("@sinclair/typebox").TObject<{
+    version: import("@sinclair/typebox").TInteger;
+}>;
+export type RevertAppletRequest = Static<typeof revertAppletRequestSchema>;
+export interface AppletResponse {
+    applet: Applet;
+}
+export interface ListAppletsResponse {
+    applets: readonly Applet[];
+}
+export type AppletManagementErrorCode = "invalid_request" | "invalid_applet" | "applet_not_found";
+export interface AppletManagementErrorResponse {
+    error: {
+        code: AppletManagementErrorCode;
+        message: string;
+    };
+}
+/**
+ * Applets changed. Live-only, carrying the whole current set so a reconnecting client reads the
+ * current applets instead of replaying every past import.
+ */
+export interface AppletsChangedEvent {
+    createdAt: number;
+    data: {
+        applets: readonly Applet[];
+    };
+    id: EventId;
+    type: "applets_changed";
+}

package/dist/protocol/Attachment.d.ts

@@ -0,0 +1,96 @@
+import { type Static } from "@sinclair/typebox";
+export declare const AttachmentImagePreviewSchema: import("@sinclair/typebox").TObject<{
+    downloadUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    height: import("@sinclair/typebox").TInteger;
+    mediaType: import("@sinclair/typebox").TLiteral<"image/png">;
+    path: import("@sinclair/typebox").TString;
+    thumbhash: import("@sinclair/typebox").TString;
+    width: import("@sinclair/typebox").TInteger;
+}>;
+export declare const SecretRequestAttachmentSchema: import("@sinclair/typebox").TObject<{
+    description: import("@sinclair/typebox").TString;
+    environmentVariables: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    id: import("@sinclair/typebox").TString;
+    instructions: import("@sinclair/typebox").TString;
+    kind: import("@sinclair/typebox").TLiteral<"secret_request">;
+    operation: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"create">, import("@sinclair/typebox").TLiteral<"update">]>;
+    secretId: import("@sinclair/typebox").TString;
+}>;
+export declare const AttachmentSchema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+    bytes: import("@sinclair/typebox").TInteger;
+    height: import("@sinclair/typebox").TInteger;
+    kind: import("@sinclair/typebox").TLiteral<"image">;
+    mediaType: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    thumbhash: import("@sinclair/typebox").TString;
+    width: import("@sinclair/typebox").TInteger;
+    downloadUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    id: import("@sinclair/typebox").TString;
+    source: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    bytes: import("@sinclair/typebox").TInteger;
+    duration: import("@sinclair/typebox").TNumber;
+    height: import("@sinclair/typebox").TInteger;
+    kind: import("@sinclair/typebox").TLiteral<"video">;
+    mediaType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    name: import("@sinclair/typebox").TString;
+    preview: import("@sinclair/typebox").TObject<{
+        downloadUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        height: import("@sinclair/typebox").TInteger;
+        mediaType: import("@sinclair/typebox").TLiteral<"image/png">;
+        path: import("@sinclair/typebox").TString;
+        thumbhash: import("@sinclair/typebox").TString;
+        width: import("@sinclair/typebox").TInteger;
+    }>;
+    width: import("@sinclair/typebox").TInteger;
+    downloadUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    id: import("@sinclair/typebox").TString;
+    source: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    bytes: import("@sinclair/typebox").TInteger;
+    duration: import("@sinclair/typebox").TNumber;
+    kind: import("@sinclair/typebox").TLiteral<"audio">;
+    mediaType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    name: import("@sinclair/typebox").TString;
+    downloadUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    id: import("@sinclair/typebox").TString;
+    source: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    image: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    kind: import("@sinclair/typebox").TLiteral<"url">;
+    siteName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    title: import("@sinclair/typebox").TString;
+    downloadUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    id: import("@sinclair/typebox").TString;
+    source: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    bytes: import("@sinclair/typebox").TInteger;
+    kind: import("@sinclair/typebox").TLiteral<"file">;
+    mediaType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    name: import("@sinclair/typebox").TString;
+    downloadUrl: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    id: import("@sinclair/typebox").TString;
+    source: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    description: import("@sinclair/typebox").TString;
+    id: import("@sinclair/typebox").TString;
+    image: import("@sinclair/typebox").TString;
+    kind: import("@sinclair/typebox").TLiteral<"applet">;
+    name: import("@sinclair/typebox").TString;
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    query: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>>;
+    thumbhash: import("@sinclair/typebox").TString;
+    applet: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    description: import("@sinclair/typebox").TString;
+    environmentVariables: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    id: import("@sinclair/typebox").TString;
+    instructions: import("@sinclair/typebox").TString;
+    kind: import("@sinclair/typebox").TLiteral<"secret_request">;
+    operation: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"create">, import("@sinclair/typebox").TLiteral<"update">]>;
+    secretId: import("@sinclair/typebox").TString;
+}>]>;
+export type AttachmentImagePreview = Static<typeof AttachmentImagePreviewSchema>;
+export type SecretRequestAttachment = Static<typeof SecretRequestAttachmentSchema>;
+export type Attachment = Static<typeof AttachmentSchema>;