@distilled.cloud/fly-io 0.30.3 → 1.0.0-rc.10

package/src/services/sprites.ts

@@ -0,0 +1,917 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs. Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import type * as Redacted from "effect/Redacted";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  SpritesProtocol,
+  type SpritesOpError,
+  type SpritesOpContext,
+} from "../protocol.ts";
+import { paginateCursor } from "../pagination.ts";
+import {
+  BadRequest,
+  Conflict,
+  NotFound,
+  SpritesNotEnabled,
+} from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { SpritesOpError, SpritesOpContext };
+
+export interface CreateCheckpointRequest {
+  name: string;
+  comment?: string;
+}
+export const CreateCheckpointRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    comment: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/sprites/{name}/checkpoint", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateCheckpointRequest",
+}) as any as S.Schema<CreateCheckpointRequest>;
+
+export interface StreamEvent {
+  type?: string;
+  data?: string;
+  error?: string;
+  time?: string;
+}
+export const StreamEvent = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    type: S.optional(S.String),
+    data: S.optional(S.String),
+    error: S.optional(S.String),
+    time: S.optional(S.String),
+  }),
+).annotate({ identifier: "StreamEvent" }) as any as S.Schema<StreamEvent>;
+
+export type CreateCheckpointResponseBodyList = Array<StreamEvent>;
+export const CreateCheckpointResponseBodyList = /*@__PURE__*/ S.Array(
+  StreamEvent,
+) as any as S.Schema<CreateCheckpointResponseBodyList>;
+
+export type CreateCheckpointResponse = CreateCheckpointResponseBodyList;
+export const CreateCheckpointResponse = /*@__PURE__*/ S.suspend(() =>
+  CreateCheckpointResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "CreateCheckpointResponse",
+}) as any as S.Schema<CreateCheckpointResponse>;
+
+export interface CreateOrganizationTokenRequest {
+  /** Fly organization slug */
+  org: string;
+  /** Human-readable label for the minted token */
+  description?: string;
+  /** Optional Sprites invite code */
+  invite_code?: string;
+}
+export const CreateOrganizationTokenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    org: S.String.pipe(T.Label()),
+    description: S.optional(S.String),
+    invite_code: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/organizations/{org}/tokens", code: 200 }),
+  ),
+).annotate({
+  identifier: "CreateOrganizationTokenRequest",
+}) as any as S.Schema<CreateOrganizationTokenRequest>;
+
+export interface CreateOrganizationTokenResponse {
+  /** Sprites bearer token. Send as Authorization: Bearer on subsequent sprite ops. */
+  token: string | Redacted.Redacted<string>;
+}
+export const CreateOrganizationTokenResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    token: S.String.pipe(T.SensitiveValue({})),
+  }),
+).annotate({
+  identifier: "CreateOrganizationTokenResponse",
+}) as any as S.Schema<CreateOrganizationTokenResponse>;
+
+export type UrlAuth = "sprite" | "public";
+export const UrlAuth = S.String;
+
+export interface UrlSettings {
+  auth?: UrlAuth | (string & {});
+  private_access?: string;
+}
+export const UrlSettings = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    auth: S.optional(UrlAuth),
+    private_access: S.optional(S.String),
+  }),
+).annotate({ identifier: "UrlSettings" }) as any as S.Schema<UrlSettings>;
+
+/** Labels stamped on the sprite (used for ownership / nuke) */
+export type CreateSpriteRequestLabelsList = Array<string>;
+export const CreateSpriteRequestLabelsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateSpriteRequestLabelsList>;
+
+export interface CreateSpriteRequest {
+  /** Unique name for the sprite within the organization */
+  name: string;
+  url_settings?: UrlSettings;
+  /** Labels stamped on the sprite (used for ownership / nuke) */
+  labels?: CreateSpriteRequestLabelsList;
+}
+export const CreateSpriteRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String,
+    url_settings: S.optional(UrlSettings),
+    labels: S.optional(CreateSpriteRequestLabelsList),
+  }).pipe(T.Http({ method: "POST", uri: "/sprites", code: 200 })),
+).annotate({
+  identifier: "CreateSpriteRequest",
+}) as any as S.Schema<CreateSpriteRequest>;
+
+export type SpriteStatus = "cold" | "warm" | "running";
+export const SpriteStatus = S.String;
+
+export type SpriteLabelsList = Array<string>;
+export const SpriteLabelsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<SpriteLabelsList>;
+
+export interface Sprite {
+  id?: string;
+  name?: string;
+  organization?: string;
+  org_slug?: string;
+  url?: string;
+  url_settings?: UrlSettings;
+  status?: SpriteStatus;
+  labels?: SpriteLabelsList;
+  created_at?: string;
+  updated_at?: string;
+  last_started_at?: string | null;
+  last_active_at?: string | null;
+  last_running_at?: string | null;
+  version?: string | null;
+}
+export const Sprite = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+    organization: S.optional(S.String),
+    org_slug: S.optional(S.String),
+    url: S.optional(S.String),
+    url_settings: S.optional(UrlSettings),
+    status: S.optional(SpriteStatus),
+    labels: S.optional(SpriteLabelsList),
+    created_at: S.optional(S.String),
+    updated_at: S.optional(S.String),
+    last_started_at: S.optional(S.NullOr(S.String)),
+    last_active_at: S.optional(S.NullOr(S.String)),
+    last_running_at: S.optional(S.NullOr(S.String)),
+    version: S.optional(S.NullOr(S.String)),
+  }),
+).annotate({ identifier: "Sprite" }) as any as S.Schema<Sprite>;
+
+export interface DeleteSpriteRequest {
+  /** Unique sprite name */
+  name: string;
+}
+export const DeleteSpriteRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "DELETE", uri: "/sprites/{name}", code: 200 })),
+).annotate({
+  identifier: "DeleteSpriteRequest",
+}) as any as S.Schema<DeleteSpriteRequest>;
+
+export interface DeleteSpriteResponse {}
+export const DeleteSpriteResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteSpriteResponse",
+}) as any as S.Schema<DeleteSpriteResponse>;
+
+export type ExecCommandRequestCmdList = Array<string>;
+export const ExecCommandRequestCmdList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ExecCommandRequestCmdList>;
+
+export type ExecCommandRequestEnvList = Array<string>;
+export const ExecCommandRequestEnvList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ExecCommandRequestEnvList>;
+
+export interface ExecCommandRequest {
+  name: string;
+  /** Command and args (repeatable) */
+  cmd: ExecCommandRequestCmdList;
+  /** Explicit path to the executable */
+  path?: string;
+  /** Read stdin from the request body */
+  stdin?: boolean;
+  /** Environment variables as KEY=VALUE (repeatable) */
+  env?: ExecCommandRequestEnvList;
+  /** Working directory */
+  dir?: string;
+  body?: Uint8Array | string;
+}
+export const ExecCommandRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    cmd: ExecCommandRequestCmdList.pipe(T.Query()),
+    path: S.optional(S.String.pipe(T.Query())),
+    stdin: S.optional(S.Boolean.pipe(T.Query())),
+    env: S.optional(ExecCommandRequestEnvList.pipe(T.Query())),
+    dir: S.optional(S.String.pipe(T.Query())),
+    body: S.optional(S.String.pipe(T.HttpBody())),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sprites/{name}/exec",
+      code: 200,
+      bodyMediaType: "application/octet-stream",
+    }),
+  ),
+).annotate({
+  identifier: "ExecCommandRequest",
+}) as any as S.Schema<ExecCommandRequest>;
+
+export interface ExecResult {
+  exit_code?: number;
+  stdout?: string;
+  stderr?: string;
+}
+export const ExecResult = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    exit_code: S.optional(S.Number),
+    stdout: S.optional(S.String),
+    stderr: S.optional(S.String),
+  }),
+).annotate({ identifier: "ExecResult" }) as any as S.Schema<ExecResult>;
+
+export interface GetCheckpointRequest {
+  name: string;
+  /** Checkpoint identifier (e.g. v7) */
+  checkpoint_id: string;
+}
+export const GetCheckpointRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    checkpoint_id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sprites/{name}/checkpoints/{checkpoint_id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetCheckpointRequest",
+}) as any as S.Schema<GetCheckpointRequest>;
+
+export interface Checkpoint {
+  id?: string;
+  create_time?: string;
+  source_id?: string;
+  comment?: string;
+  health?: string;
+}
+export const Checkpoint = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    create_time: S.optional(S.String),
+    source_id: S.optional(S.String),
+    comment: S.optional(S.String),
+    health: S.optional(S.String),
+  }),
+).annotate({ identifier: "Checkpoint" }) as any as S.Schema<Checkpoint>;
+
+export interface GetServiceRequest {
+  name: string;
+  service_name: string;
+}
+export const GetServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    service_name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/sprites/{name}/services/{service_name}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetServiceRequest",
+}) as any as S.Schema<GetServiceRequest>;
+
+export type SpriteServiceArgsList = Array<string>;
+export const SpriteServiceArgsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<SpriteServiceArgsList>;
+
+export type SpriteServiceNeedsList = Array<string>;
+export const SpriteServiceNeedsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<SpriteServiceNeedsList>;
+
+export interface SpriteServiceState {
+  name?: string;
+  status?: string;
+  pid?: number;
+  started_at?: string;
+  error?: string;
+}
+export const SpriteServiceState = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    status: S.optional(S.String),
+    pid: S.optional(S.Number),
+    started_at: S.optional(S.String),
+    error: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "SpriteServiceState",
+}) as any as S.Schema<SpriteServiceState>;
+
+export interface SpriteService {
+  name?: string;
+  cmd?: string;
+  args?: SpriteServiceArgsList;
+  needs?: SpriteServiceNeedsList;
+  http_port?: number;
+  state?: SpriteServiceState;
+}
+export const SpriteService = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.optional(S.String),
+    cmd: S.optional(S.String),
+    args: S.optional(SpriteServiceArgsList),
+    needs: S.optional(SpriteServiceNeedsList),
+    http_port: S.optional(S.Number),
+    state: S.optional(SpriteServiceState),
+  }),
+).annotate({ identifier: "SpriteService" }) as any as S.Schema<SpriteService>;
+
+export interface GetSpriteRequest {
+  /** Unique sprite name */
+  name: string;
+}
+export const GetSpriteRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/sprites/{name}", code: 200 })),
+).annotate({
+  identifier: "GetSpriteRequest",
+}) as any as S.Schema<GetSpriteRequest>;
+
+export interface ListCheckpointsRequest {
+  name: string;
+}
+export const ListCheckpointsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/sprites/{name}/checkpoints", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListCheckpointsRequest",
+}) as any as S.Schema<ListCheckpointsRequest>;
+
+export type ListCheckpointsResponseBodyList = Array<Checkpoint>;
+export const ListCheckpointsResponseBodyList = /*@__PURE__*/ S.Array(
+  Checkpoint,
+) as any as S.Schema<ListCheckpointsResponseBodyList>;
+
+export type ListCheckpointsResponse = ListCheckpointsResponseBodyList;
+export const ListCheckpointsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListCheckpointsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListCheckpointsResponse",
+}) as any as S.Schema<ListCheckpointsResponse>;
+
+export interface ListExecSessionsRequest {
+  name: string;
+}
+export const ListExecSessionsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(T.Http({ method: "GET", uri: "/sprites/{name}/exec", code: 200 })),
+).annotate({
+  identifier: "ListExecSessionsRequest",
+}) as any as S.Schema<ListExecSessionsRequest>;
+
+export interface ExecSession {
+  id?: string;
+  command?: string;
+  is_active?: boolean;
+  tty?: boolean;
+  created?: string;
+  last_activity?: string;
+  workdir?: string;
+  bytes_per_second?: number;
+}
+export const ExecSession = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.optional(S.String),
+    command: S.optional(S.String),
+    is_active: S.optional(S.Boolean),
+    tty: S.optional(S.Boolean),
+    created: S.optional(S.String),
+    last_activity: S.optional(S.String),
+    workdir: S.optional(S.String),
+    bytes_per_second: S.optional(S.Number),
+  }),
+).annotate({ identifier: "ExecSession" }) as any as S.Schema<ExecSession>;
+
+export type ListExecSessionsResponseBodyList = Array<ExecSession>;
+export const ListExecSessionsResponseBodyList = /*@__PURE__*/ S.Array(
+  ExecSession,
+) as any as S.Schema<ListExecSessionsResponseBodyList>;
+
+export type ListExecSessionsResponse = ListExecSessionsResponseBodyList;
+export const ListExecSessionsResponse = /*@__PURE__*/ S.suspend(() =>
+  ListExecSessionsResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListExecSessionsResponse",
+}) as any as S.Schema<ListExecSessionsResponse>;
+
+export interface ListServicesRequest {
+  name: string;
+}
+export const ListServicesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/sprites/{name}/services", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListServicesRequest",
+}) as any as S.Schema<ListServicesRequest>;
+
+export type ListServicesResponseBodyList = Array<SpriteService>;
+export const ListServicesResponseBodyList = /*@__PURE__*/ S.Array(
+  SpriteService,
+) as any as S.Schema<ListServicesResponseBodyList>;
+
+export type ListServicesResponse = ListServicesResponseBodyList;
+export const ListServicesResponse = /*@__PURE__*/ S.suspend(() =>
+  ListServicesResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "ListServicesResponse",
+}) as any as S.Schema<ListServicesResponse>;
+
+export interface ListSpritesRequest {
+  /** Filter sprites by name prefix */
+  prefix?: string;
+  /** Maximum number of results (1-50, default 50) */
+  max_results?: number;
+  /** Token from the previous response */
+  continuation_token?: string;
+}
+export const ListSpritesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    prefix: S.optional(S.String.pipe(T.Query())),
+    max_results: S.optional(S.Number.pipe(T.Query())),
+    continuation_token: S.optional(S.String.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/sprites", code: 200 })),
+).annotate({
+  identifier: "ListSpritesRequest",
+}) as any as S.Schema<ListSpritesRequest>;
+
+export type ListSpritesResponseSpritesList = Array<Sprite>;
+export const ListSpritesResponseSpritesList = /*@__PURE__*/ S.Array(
+  Sprite,
+) as any as S.Schema<ListSpritesResponseSpritesList>;
+
+export interface ListSpritesResponse {
+  sprites: ListSpritesResponseSpritesList;
+  has_more?: boolean;
+  next_continuation_token?: string | null;
+  name?: string;
+  running?: number;
+  warm?: number;
+  cold?: number;
+  running_limit?: number;
+  warm_limit?: number;
+}
+export const ListSpritesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sprites: ListSpritesResponseSpritesList,
+    has_more: S.optional(S.Boolean),
+    next_continuation_token: S.optional(S.NullOr(S.String)),
+    name: S.optional(S.String),
+    running: S.optional(S.Number),
+    warm: S.optional(S.Number),
+    cold: S.optional(S.Number),
+    running_limit: S.optional(S.Number),
+    warm_limit: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "ListSpritesResponse",
+}) as any as S.Schema<ListSpritesResponse>;
+
+/** Command arguments */
+export type PutServiceRequestArgsList = Array<string>;
+export const PutServiceRequestArgsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<PutServiceRequestArgsList>;
+
+/** Service dependencies (started first) */
+export type PutServiceRequestNeedsList = Array<string>;
+export const PutServiceRequestNeedsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<PutServiceRequestNeedsList>;
+
+export interface PutServiceRequest {
+  name: string;
+  service_name: string;
+  /** Time to monitor logs after starting (default 5s) */
+  duration?: string;
+  /** Command to execute */
+  cmd: string;
+  /** Command arguments */
+  args?: PutServiceRequestArgsList;
+  /** Working directory for the service */
+  dir?: string;
+  /** Service dependencies (started first) */
+  needs?: PutServiceRequestNeedsList;
+  /** HTTP port for proxy routing */
+  http_port?: number;
+}
+export const PutServiceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    service_name: S.String.pipe(T.Label()),
+    duration: S.optional(S.String.pipe(T.Query())),
+    cmd: S.String,
+    args: S.optional(PutServiceRequestArgsList),
+    dir: S.optional(S.String),
+    needs: S.optional(PutServiceRequestNeedsList),
+    http_port: S.optional(S.Number),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/sprites/{name}/services/{service_name}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "PutServiceRequest",
+}) as any as S.Schema<PutServiceRequest>;
+
+export type PutServiceResponseBodyList = Array<StreamEvent>;
+export const PutServiceResponseBodyList = /*@__PURE__*/ S.Array(
+  StreamEvent,
+) as any as S.Schema<PutServiceResponseBodyList>;
+
+export type PutServiceResponse = PutServiceResponseBodyList;
+export const PutServiceResponse = /*@__PURE__*/ S.suspend(() =>
+  PutServiceResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "PutServiceResponse",
+}) as any as S.Schema<PutServiceResponse>;
+
+export interface RestoreCheckpointRequest {
+  name: string;
+  checkpoint_id: string;
+}
+export const RestoreCheckpointRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    checkpoint_id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sprites/{name}/checkpoints/{checkpoint_id}/restore",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RestoreCheckpointRequest",
+}) as any as S.Schema<RestoreCheckpointRequest>;
+
+export type RestoreCheckpointResponseBodyList = Array<StreamEvent>;
+export const RestoreCheckpointResponseBodyList = /*@__PURE__*/ S.Array(
+  StreamEvent,
+) as any as S.Schema<RestoreCheckpointResponseBodyList>;
+
+export type RestoreCheckpointResponse = RestoreCheckpointResponseBodyList;
+export const RestoreCheckpointResponse = /*@__PURE__*/ S.suspend(() =>
+  RestoreCheckpointResponseBodyList.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "RestoreCheckpointResponse",
+}) as any as S.Schema<RestoreCheckpointResponse>;
+
+export interface UpdateSpriteRequest {
+  /** Unique sprite name */
+  name: string;
+  url_settings: UrlSettings;
+}
+export const UpdateSpriteRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    url_settings: UrlSettings,
+  }).pipe(T.Http({ method: "PUT", uri: "/sprites/{name}", code: 200 })),
+).annotate({
+  identifier: "UpdateSpriteRequest",
+}) as any as S.Schema<UpdateSpriteRequest>;
+
+export interface WriteFileRequest {
+  name: string;
+  /** Path to the file to write */
+  path: string;
+  /** Working directory for resolving relative paths */
+  workingDir: string;
+  /** File permissions in octal (e.g. 0644) */
+  mode?: string;
+  /** Create parent directories if they do not exist */
+  mkdir?: boolean;
+  body: Uint8Array | string;
+}
+export const WriteFileRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    path: S.String.pipe(T.Query()),
+    workingDir: S.String.pipe(T.Query()),
+    mode: S.optional(S.String.pipe(T.Query())),
+    mkdir: S.optional(S.Boolean.pipe(T.Query())),
+    body: S.String.pipe(T.HttpBody()),
+  }).pipe(
+    T.Http({
+      method: "PUT",
+      uri: "/sprites/{name}/fs/write",
+      code: 200,
+      bodyMediaType: "application/octet-stream",
+    }),
+  ),
+).annotate({
+  identifier: "WriteFileRequest",
+}) as any as S.Schema<WriteFileRequest>;
+
+export interface WriteFileResponse {
+  path?: string;
+  size?: number;
+  mode?: string;
+}
+export const WriteFileResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.optional(S.String),
+    size: S.optional(S.Number),
+    mode: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "WriteFileResponse",
+}) as any as S.Schema<WriteFileResponse>;
+
+export type CreateCheckpointError = NotFound | SpritesOpError;
+/** Create a checkpoint (NDJSON progress stream) */
+export const createCheckpoint: API.OperationMethod<
+  CreateCheckpointRequest,
+  CreateCheckpointResponse,
+  CreateCheckpointError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateCheckpointRequest,
+  output: CreateCheckpointResponse,
+  errors: [NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateOrganizationTokenError = SpritesNotEnabled | SpritesOpError;
+/** Mint a Sprites bearer token from a Fly.io macaroon POST with Authorization: FlyV1 {FLY_API_TOKEN}. Sprite CRUD rejects Bearer FLY_API_TOKEN (401); callers mint once, cache, then Bearer the returned token. 401 with 'sprites not enabled' means the org has not enabled Sprites. */
+export const createOrganizationToken: API.OperationMethod<
+  CreateOrganizationTokenRequest,
+  CreateOrganizationTokenResponse,
+  CreateOrganizationTokenError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateOrganizationTokenRequest,
+  output: CreateOrganizationTokenResponse,
+  errors: [SpritesNotEnabled],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type CreateSpriteError = BadRequest | Conflict | SpritesOpError;
+/** Create a sprite */
+export const createSprite: API.OperationMethod<
+  CreateSpriteRequest,
+  Sprite,
+  CreateSpriteError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateSpriteRequest,
+  output: Sprite,
+  errors: [BadRequest, Conflict],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteSpriteError = NotFound | SpritesOpError;
+/** Delete a sprite */
+export const deleteSprite: API.OperationMethod<
+  DeleteSpriteRequest,
+  DeleteSpriteResponse,
+  DeleteSpriteError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteSpriteRequest,
+  output: DeleteSpriteResponse,
+  errors: [NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ExecCommandError = BadRequest | NotFound | SpritesOpError;
+/** Execute a command via HTTP POST (non-TTY). Simpler than the WebSocket exec API. */
+export const execCommand: API.OperationMethod<
+  ExecCommandRequest,
+  ExecResult,
+  ExecCommandError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ExecCommandRequest,
+  output: ExecResult,
+  errors: [BadRequest, NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetCheckpointError = NotFound | SpritesOpError;
+/** Get a checkpoint */
+export const getCheckpoint: API.OperationMethod<
+  GetCheckpointRequest,
+  Checkpoint,
+  GetCheckpointError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetCheckpointRequest,
+  output: Checkpoint,
+  errors: [NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetServiceError = NotFound | SpritesOpError;
+/** Get a sprite service */
+export const getService: API.OperationMethod<
+  GetServiceRequest,
+  SpriteService,
+  GetServiceError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetServiceRequest,
+  output: SpriteService,
+  errors: [NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetSpriteError = NotFound | SpritesOpError;
+/** Get a sprite */
+export const getSprite: API.OperationMethod<
+  GetSpriteRequest,
+  Sprite,
+  GetSpriteError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetSpriteRequest,
+  output: Sprite,
+  errors: [NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListCheckpointsError = NotFound | SpritesOpError;
+/** List checkpoints */
+export const listCheckpoints: API.OperationMethod<
+  ListCheckpointsRequest,
+  ListCheckpointsResponse,
+  ListCheckpointsError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListCheckpointsRequest,
+  output: ListCheckpointsResponse,
+  errors: [NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListExecSessionsError = NotFound | SpritesOpError;
+/** List active exec sessions */
+export const listExecSessions: API.OperationMethod<
+  ListExecSessionsRequest,
+  ListExecSessionsResponse,
+  ListExecSessionsError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListExecSessionsRequest,
+  output: ListExecSessionsResponse,
+  errors: [NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListServicesError = NotFound | SpritesOpError;
+/** List configured sprite services */
+export const listServices: API.OperationMethod<
+  ListServicesRequest,
+  ListServicesResponse,
+  ListServicesError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListServicesRequest,
+  output: ListServicesResponse,
+  errors: [NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListSpritesError = SpritesOpError;
+/** List sprites for the authenticated organization */
+export const listSprites: API.PaginatedOperationMethod<
+  ListSpritesRequest,
+  ListSpritesResponse,
+  ListSpritesError,
+  SpritesOpContext,
+  Sprite
+> = /*@__PURE__*/ API.makePaginated(
+  () => ({
+    input: ListSpritesRequest,
+    output: ListSpritesResponse,
+    errors: [],
+    protocol: SpritesProtocol,
+    retry: Retry.Retry,
+    pagination: {
+      inputToken: "continuation_token",
+      outputToken: "next_continuation_token",
+      items: "sprites",
+      pageSize: "max_results",
+      mode: "cursor",
+    } as const,
+  }),
+  paginateCursor,
+) as any;
+
+export type PutServiceError = BadRequest | NotFound | SpritesOpError;
+/** Create or update a sprite service. Returns NDJSON start progress. */
+export const putService: API.OperationMethod<
+  PutServiceRequest,
+  PutServiceResponse,
+  PutServiceError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PutServiceRequest,
+  output: PutServiceResponse,
+  errors: [BadRequest, NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestoreCheckpointError = NotFound | SpritesOpError;
+/** Restore a checkpoint (NDJSON progress stream). Destructive. */
+export const restoreCheckpoint: API.OperationMethod<
+  RestoreCheckpointRequest,
+  RestoreCheckpointResponse,
+  RestoreCheckpointError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestoreCheckpointRequest,
+  output: RestoreCheckpointResponse,
+  errors: [NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type UpdateSpriteError = NotFound | SpritesOpError;
+/** Update sprite URL auth settings */
+export const updateSprite: API.OperationMethod<
+  UpdateSpriteRequest,
+  Sprite,
+  UpdateSpriteError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: UpdateSpriteRequest,
+  output: Sprite,
+  errors: [NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));
+
+export type WriteFileError = BadRequest | NotFound | SpritesOpError;
+/** Write file contents to the sprite filesystem. Request body is raw file bytes. */
+export const writeFile: API.OperationMethod<
+  WriteFileRequest,
+  WriteFileResponse,
+  WriteFileError,
+  SpritesOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: WriteFileRequest,
+  output: WriteFileResponse,
+  errors: [BadRequest, NotFound],
+  protocol: SpritesProtocol,
+  retry: Retry.Retry,
+}));