opencode/packages/httpapi-codegen/test/generated/session.ts

// Generated by @opencode-ai/httpapi-codegen. Do not edit.
import { Effect, Schema } from "effect"
import { Sse } from "effect/unstable/encoding"
import { HttpClientError } from "effect/unstable/http"
import { HttpApiClient, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi"
import { ClientError } from "./client-error.js"

const EndpointHealthSuccess = Schema.String

const EndpointListQuery = Schema.Struct({
  archived: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Undefined])),
})

const EndpointListSuccess = Schema.Array(Schema.String)

const EndpointGetParams = Schema.Struct({ sessionID: Schema.String })

const EndpointGetSuccess = Schema.Struct({ data: Schema.String })

class EndpointGetError0Class extends Schema.TaggedError<EndpointGetError0Class>("Missing")("Missing", {
  message: Schema.String,
}) {}
const EndpointGetError0 = EndpointGetError0Class.annotate({ httpApiStatus: 404 })

const EndpointInterruptParams = Schema.Struct({ sessionID: Schema.String })

const EndpointInterruptSuccess = Schema.Void.annotate({ httpApiStatus: 204 })

const EndpointConfigureParams = Schema.Struct({ sessionID: Schema.String })

const EndpointConfigureQuery = Schema.Struct({
  dryRun: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Undefined])),
})

const EndpointConfigureHeaders = Schema.Struct({ traceID: Schema.String })

const EndpointConfigurePayload0 = Schema.Union([
  Schema.Struct({ type: Schema.Literal("local"), command: Schema.Array(Schema.String) }),
  Schema.Struct({ type: Schema.Literal("remote"), url: Schema.String }),
])

const EndpointConfigureSuccess = Schema.String

export const GroupSession = HttpApiGroup.make("session", { topLevel: false })
  .add(HttpApiEndpoint.make("GET")("health", "/session/health", { success: EndpointHealthSuccess }))
  .add(HttpApiEndpoint.make("GET")("list", "/session", { query: EndpointListQuery, success: EndpointListSuccess }))
  .add(
    HttpApiEndpoint.make("GET")("get", "/session/:sessionID", {
      params: EndpointGetParams,
      success: EndpointGetSuccess,
      error: EndpointGetError0,
    }),
  )
  .add(
    HttpApiEndpoint.make("POST")("interrupt", "/session/:sessionID/interrupt", {
      params: EndpointInterruptParams,
      success: EndpointInterruptSuccess,
    }),
  )
  .add(
    HttpApiEndpoint.make("POST")("configure", "/session/:sessionID/configure", {
      params: EndpointConfigureParams,
      query: EndpointConfigureQuery,
      headers: EndpointConfigureHeaders,
      payload: EndpointConfigurePayload0,
      success: EndpointConfigureSuccess,
    }),
  )

type RawGroup = HttpApiClient.Client.Group<typeof GroupSession, never, never>

const EndpointHealthDeclaredError = Schema.Never
const mapEndpointHealthError = (error: unknown) =>
  HttpClientError.isHttpClientError(error) || Schema.isSchemaError(error) || Sse.Retry.is(error)
    ? new ClientError({ cause: error })
    : Schema.is(EndpointHealthDeclaredError)(error)
      ? error
      : new ClientError({ cause: error })
const EndpointHealth = (raw: RawGroup) => () => raw["health"]({}).pipe(Effect.mapError(mapEndpointHealthError))

type EndpointListInput = { readonly archived?: (typeof EndpointListQuery.Type)["archived"] }
const EndpointListDeclaredError = Schema.Never
const mapEndpointListError = (error: unknown) =>
  HttpClientError.isHttpClientError(error) || Schema.isSchemaError(error) || Sse.Retry.is(error)
    ? new ClientError({ cause: error })
    : Schema.is(EndpointListDeclaredError)(error)
      ? error
      : new ClientError({ cause: error })
const EndpointList = (raw: RawGroup) => (input?: EndpointListInput) =>
  raw["list"]({ query: { archived: input?.["archived"] } }).pipe(Effect.mapError(mapEndpointListError))

type EndpointGetInput = { readonly sessionID: (typeof EndpointGetParams.Type)["sessionID"] }
const EndpointGetDeclaredError = Schema.Union([EndpointGetError0])
const mapEndpointGetError = (error: unknown) =>
  HttpClientError.isHttpClientError(error) || Schema.isSchemaError(error) || Sse.Retry.is(error)
    ? new ClientError({ cause: error })
    : Schema.is(EndpointGetDeclaredError)(error)
      ? error
      : new ClientError({ cause: error })
const EndpointGet = (raw: RawGroup) => (input: EndpointGetInput) =>
  raw["get"]({ params: { sessionID: input["sessionID"] } }).pipe(
    Effect.mapError(mapEndpointGetError),
    Effect.map((value) => value.data),
  )

type EndpointInterruptInput = { readonly sessionID: (typeof EndpointInterruptParams.Type)["sessionID"] }
const EndpointInterruptDeclaredError = Schema.Never
const mapEndpointInterruptError = (error: unknown) =>
  HttpClientError.isHttpClientError(error) || Schema.isSchemaError(error) || Sse.Retry.is(error)
    ? new ClientError({ cause: error })
    : Schema.is(EndpointInterruptDeclaredError)(error)
      ? error
      : new ClientError({ cause: error })
const EndpointInterrupt = (raw: RawGroup) => (input: EndpointInterruptInput) =>
  raw["interrupt"]({ params: { sessionID: input["sessionID"] } }).pipe(Effect.mapError(mapEndpointInterruptError))

type EndpointConfigureRequest = Parameters<RawGroup["configure"]>[0]
type EndpointConfigureInput = {
  readonly sessionID: (typeof EndpointConfigureParams.Type)["sessionID"]
  readonly dryRun?: (typeof EndpointConfigureQuery.Type)["dryRun"]
  readonly traceID: (typeof EndpointConfigureHeaders.Type)["traceID"]
  readonly payload: typeof EndpointConfigurePayload0.Type
}
const EndpointConfigureDeclaredError = Schema.Never
const mapEndpointConfigureError = (error: unknown) =>
  HttpClientError.isHttpClientError(error) || Schema.isSchemaError(error) || Sse.Retry.is(error)
    ? new ClientError({ cause: error })
    : Schema.is(EndpointConfigureDeclaredError)(error)
      ? error
      : new ClientError({ cause: error })
const EndpointConfigure = (raw: RawGroup) => (input: EndpointConfigureInput) =>
  raw["configure"]({
    params: { sessionID: input["sessionID"] },
    query: { dryRun: input["dryRun"] },
    headers: { traceID: input["traceID"] },
    payload: input["payload"],
  } as EndpointConfigureRequest).pipe(Effect.mapError(mapEndpointConfigureError))

export const adaptGroupSession = (raw: RawGroup) => ({
  health: EndpointHealth(raw),
  list: EndpointList(raw),
  get: EndpointGet(raw),
  interrupt: EndpointInterrupt(raw),
  configure: EndpointConfigure(raw),
})