@sealant/api-contracts-next 0.39.0-next.749 → 0.39.0-next.751

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (32) hide show
  1. package/dist/core-api/access-tokens.d.ts +9 -9
  2. package/dist/core-api/access-tokens.js +4 -4
  3. package/dist/core-api/budgets.js +1 -1
  4. package/dist/core-api/connected-accounts.d.ts +12 -12
  5. package/dist/core-api/connected-accounts.js +6 -6
  6. package/dist/core-api/control-plane.d.ts +826 -826
  7. package/dist/core-api/control-plane.js +1 -1
  8. package/dist/core-api/github.d.ts +27 -27
  9. package/dist/core-api/github.js +7 -7
  10. package/dist/core-api/inference.d.ts +4 -4
  11. package/dist/core-api/inference.js +6 -6
  12. package/dist/core-api/packages.d.ts +4 -4
  13. package/dist/core-api/packages.js +3 -3
  14. package/dist/core-api/profiles.d.ts +10 -10
  15. package/dist/core-api/profiles.js +5 -5
  16. package/dist/core-api/registries.d.ts +14 -14
  17. package/dist/core-api/registries.js +3 -3
  18. package/dist/core-api/request-refusal.d.ts +8 -7
  19. package/dist/core-api/request-refusal.js +12 -12
  20. package/dist/core-api/runs.d.ts +27 -27
  21. package/dist/core-api/runs.js +4 -4
  22. package/dist/core-api/sessions.d.ts +35 -35
  23. package/dist/core-api/sessions.js +8 -8
  24. package/dist/core-api/ssh-keys.d.ts +12 -12
  25. package/dist/core-api/ssh-keys.js +7 -7
  26. package/dist/core-api/system.d.ts +6 -6
  27. package/dist/core-api/system.js +2 -2
  28. package/dist/core-api/users.d.ts +9 -9
  29. package/dist/core-api/users.js +5 -5
  30. package/dist/core-api/workspaces.d.ts +75 -75
  31. package/dist/core-api/workspaces.js +13 -13
  32. package/package.json +3 -3
package/dist/core-api/runs.d.ts CHANGED
@@ -10,7 +10,7 @@
10
10
  * so values past 2^53 survive; the SDK and API layer convert to/from `bigint`.
11
11
  */
12
12
  import { Schema } from "effect";
13
- import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
13
+ import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
14
14
  import { BudgetExceededError } from "./budgets.js";
15
15
  export declare const runStatusSchema: Schema.Literals<readonly ["queued", "running", "completed", "failed", "cancelled"]>;
16
16
  export type RunStatusWire = typeof runStatusSchema.Type;
@@ -312,7 +312,7 @@ declare const RunInternalServerError_base: Schema.Class<RunInternalServerError,
312
312
  }>, import("effect/Cause").YieldableError>;
313
313
  export declare class RunInternalServerError extends RunInternalServerError_base {
314
314
  }
315
- export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoint.HttpApiEndpoint<"createRun", "POST", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
315
+ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoint.HttpApiEndpoint<"createRun", "POST", "/", never, never, Schema.toCodecJson<Schema.Struct<{
316
316
  readonly workspaceId: Schema.String;
317
317
  readonly harnessId: Schema.String;
318
318
  readonly ownerUserId: Schema.String;
@@ -326,7 +326,7 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
326
326
  }>>;
327
327
  /** Opaque caller correlation bag ({ projectId, sessionId, ... }): stored + echoed, no semantics. */
328
328
  readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
329
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
329
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
330
330
  readonly runId: Schema.String;
331
331
  readonly workspaceId: Schema.String;
332
332
  readonly attemptId: Schema.optional<Schema.String>;
@@ -361,11 +361,11 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
361
361
  readonly recordDeletedAt: Schema.optional<Schema.String>;
362
362
  readonly createdAt: Schema.String;
363
363
  readonly updatedAt: Schema.String;
364
- }>>, HttpApiEndpoint.Json<typeof BudgetExceededError | typeof RunBadRequestError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRun", "GET", "/:runId", HttpApiEndpoint.StringTree<Schema.Struct<{
364
+ }>>, Schema.toCodecJson<typeof BudgetExceededError | typeof RunBadRequestError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRun", "GET", "/:runId", Schema.toCodecStringTree<Schema.Struct<{
365
365
  readonly runId: Schema.String;
366
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
366
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
367
367
  readonly ownerUserId: Schema.optional<Schema.String>;
368
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
368
+ }>>, never, never, Schema.toCodecJson<Schema.Struct<{
369
369
  readonly runId: Schema.String;
370
370
  readonly workspaceId: Schema.String;
371
371
  readonly attemptId: Schema.optional<Schema.String>;
@@ -400,11 +400,11 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
400
400
  readonly recordDeletedAt: Schema.optional<Schema.String>;
401
401
  readonly createdAt: Schema.String;
402
402
  readonly updatedAt: Schema.String;
403
- }>>, HttpApiEndpoint.Json<typeof BudgetExceededError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunChanges", "GET", "/:runId/changes", HttpApiEndpoint.StringTree<Schema.Struct<{
403
+ }>>, Schema.toCodecJson<typeof BudgetExceededError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunChanges", "GET", "/:runId/changes", Schema.toCodecStringTree<Schema.Struct<{
404
404
  readonly runId: Schema.String;
405
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
405
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
406
406
  readonly ownerUserId: Schema.optional<Schema.String>;
407
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
407
+ }>>, never, never, Schema.toCodecJson<Schema.Struct<{
408
408
  readonly files: Schema.$Array<Schema.Struct<{
409
409
  readonly path: Schema.String;
410
410
  readonly change: Schema.Literals<readonly ["added", "modified", "deleted", "renamed"]>;
@@ -420,12 +420,12 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
420
420
  readonly available: Schema.optional<Schema.Boolean>;
421
421
  /** Why the changes are not available, when `available` is `false`. */
422
422
  readonly unavailableReason: Schema.optional<Schema.String>;
423
- }>>, HttpApiEndpoint.Json<typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunEvent", "GET", "/:runId/events/:sequence", HttpApiEndpoint.StringTree<Schema.Struct<{
423
+ }>>, Schema.toCodecJson<typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunEvent", "GET", "/:runId/events/:sequence", Schema.toCodecStringTree<Schema.Struct<{
424
424
  readonly runId: Schema.String;
425
425
  readonly sequence: Schema.String;
426
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
426
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
427
427
  readonly ownerUserId: Schema.optional<Schema.String>;
428
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
428
+ }>>, never, never, Schema.toCodecJson<Schema.Struct<{
429
429
  readonly eventId: Schema.String;
430
430
  readonly runId: Schema.String;
431
431
  readonly runtimeId: Schema.String;
@@ -442,11 +442,11 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
442
442
  readonly payloadCase: Schema.String;
443
443
  readonly payload: Schema.Unknown;
444
444
  readonly ingestedAt: Schema.String;
445
- }>>, HttpApiEndpoint.Json<typeof RunBadRequestError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunLoss", "GET", "/:runId/loss", HttpApiEndpoint.StringTree<Schema.Struct<{
445
+ }>>, Schema.toCodecJson<typeof RunBadRequestError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunLoss", "GET", "/:runId/loss", Schema.toCodecStringTree<Schema.Struct<{
446
446
  readonly runId: Schema.String;
447
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
447
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
448
448
  readonly ownerUserId: Schema.optional<Schema.String>;
449
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
449
+ }>>, never, never, Schema.toCodecJson<Schema.Struct<{
450
450
  readonly runId: Schema.String;
451
451
  readonly droppedEventCount: Schema.String;
452
452
  readonly sequenceGapCount: Schema.Number;
@@ -460,9 +460,9 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
460
460
  readonly detectedVia: Schema.Literals<readonly ["marker", "gap"]>;
461
461
  readonly reason: Schema.optional<Schema.String>;
462
462
  }>>;
463
- }>>, HttpApiEndpoint.Json<typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunScrollback", "GET", "/:runId/scrollback", HttpApiEndpoint.StringTree<Schema.Struct<{
463
+ }>>, Schema.toCodecJson<typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunScrollback", "GET", "/:runId/scrollback", Schema.toCodecStringTree<Schema.Struct<{
464
464
  readonly runId: Schema.String;
465
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
465
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
466
466
  readonly ownerUserId: Schema.optional<Schema.String>;
467
467
  readonly processId: Schema.String;
468
468
  readonly stream: Schema.Literals<readonly ["stdout", "stderr", "pty"]>;
@@ -471,15 +471,15 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
471
471
  readonly fromSequence: Schema.optional<Schema.String>;
472
472
  /** Maximum chunks to reconstruct (server default 5000). */
473
473
  readonly limit: Schema.optional<Schema.String>;
474
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
474
+ }>>, never, never, Schema.toCodecJson<Schema.Struct<{
475
475
  readonly processId: Schema.String;
476
476
  readonly stream: Schema.Literals<readonly ["stdout", "stderr", "pty"]>;
477
477
  readonly byteCount: Schema.Number;
478
478
  /** Base64-encoded reconstructed bytes (byte-exact as recorded; redaction happens upstream). */
479
479
  readonly contentBase64: Schema.String;
480
- }>>, HttpApiEndpoint.Json<typeof RunBadRequestError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunTimeline", "GET", "/:runId/timeline", HttpApiEndpoint.StringTree<Schema.Struct<{
480
+ }>>, Schema.toCodecJson<typeof RunBadRequestError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRunTimeline", "GET", "/:runId/timeline", Schema.toCodecStringTree<Schema.Struct<{
481
481
  readonly runId: Schema.String;
482
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
482
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
483
483
  readonly ownerUserId: Schema.optional<Schema.String>;
484
484
  readonly fromSequence: Schema.optional<Schema.String>;
485
485
  readonly toSequence: Schema.optional<Schema.String>;
@@ -490,7 +490,7 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
490
490
  * for the ioChunk-dominated full log.
491
491
  */
492
492
  readonly kinds: Schema.optional<Schema.String>;
493
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
493
+ }>>, never, never, Schema.toCodecJson<Schema.Struct<{
494
494
  readonly items: Schema.$Array<Schema.Struct<{
495
495
  readonly eventId: Schema.String;
496
496
  readonly sequence: Schema.String;
@@ -504,12 +504,12 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
504
504
  readonly captureMethod: Schema.Number;
505
505
  readonly confidence: Schema.Number;
506
506
  }>>;
507
- }>>, HttpApiEndpoint.Json<typeof RunBadRequestError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listRuns", "GET", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
507
+ }>>, Schema.toCodecJson<typeof RunBadRequestError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listRuns", "GET", "/", never, Schema.toCodecStringTree<Schema.Struct<{
508
508
  readonly workspaceId: Schema.optional<Schema.String>;
509
509
  readonly ownerUserId: Schema.optional<Schema.String>;
510
510
  readonly status: Schema.optional<Schema.Literals<readonly ["queued", "running", "completed", "failed", "cancelled"]>>;
511
511
  readonly limit: Schema.optional<Schema.String>;
512
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
512
+ }>>, never, never, Schema.toCodecJson<Schema.Struct<{
513
513
  readonly items: Schema.$Array<Schema.Struct<{
514
514
  readonly runId: Schema.String;
515
515
  readonly workspaceId: Schema.String;
@@ -546,9 +546,9 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
546
546
  readonly createdAt: Schema.String;
547
547
  readonly updatedAt: Schema.String;
548
548
  }>>;
549
- }>>, HttpApiEndpoint.Json<typeof RunBadRequestError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"updateRun", "PATCH", "/:runId", HttpApiEndpoint.StringTree<Schema.Struct<{
549
+ }>>, Schema.toCodecJson<typeof RunBadRequestError | typeof RunInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"updateRun", "PATCH", "/:runId", Schema.toCodecStringTree<Schema.Struct<{
550
550
  readonly runId: Schema.String;
551
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
551
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
552
552
  /** The run's owner. Required by the control plane: an update that names no owner finds no run. */
553
553
  readonly ownerUserId: Schema.optional<Schema.String>;
554
554
  readonly status: Schema.optional<Schema.Literals<readonly ["queued", "running", "completed", "failed", "cancelled"]>>;
@@ -562,7 +562,7 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
562
562
  }>>>;
563
563
  /** The caller read the run's changes and the reading failed: nothing is known of them. */
564
564
  readonly changesReadFailed: Schema.optional<Schema.Boolean>;
565
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
565
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
566
566
  readonly runId: Schema.String;
567
567
  readonly workspaceId: Schema.String;
568
568
  readonly attemptId: Schema.optional<Schema.String>;
@@ -597,5 +597,5 @@ export declare const RunsGroup: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoin
597
597
  readonly recordDeletedAt: Schema.optional<Schema.String>;
598
598
  readonly createdAt: Schema.String;
599
599
  readonly updatedAt: Schema.String;
600
- }>>, HttpApiEndpoint.Json<typeof RunBadRequestError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never>, false>;
600
+ }>>, Schema.toCodecJson<typeof RunBadRequestError | typeof RunNotFoundError | typeof RunInternalServerError>, never, never>, false>;
601
601
  export {};
package/dist/core-api/runs.js CHANGED
@@ -10,7 +10,7 @@
10
10
  * so values past 2^53 survive; the SDK and API layer convert to/from `bigint`.
11
11
  */
12
12
  import { Schema } from "effect";
13
- import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
13
+ import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
14
14
  import { BudgetExceededError } from "./budgets.js";
15
15
  const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
16
16
  export const runStatusSchema = Schema.Literals([
@@ -237,11 +237,11 @@ export const runChangesResponseSchema = Schema.Struct({
237
237
  // ---------------------------------------------------------------------------------------------
238
238
  // Errors
239
239
  // ---------------------------------------------------------------------------------------------
240
- export class RunBadRequestError extends Schema.TaggedErrorClass()("RunBadRequestError", { message: Schema.String }, { httpApiStatus: 400 }) {
240
+ export class RunBadRequestError extends Schema.TaggedError()("RunBadRequestError", { message: Schema.String }, { httpApiStatus: 400 }) {
241
241
  }
242
- export class RunNotFoundError extends Schema.TaggedErrorClass()("RunNotFoundError", { message: Schema.String }, { httpApiStatus: 404 }) {
242
+ export class RunNotFoundError extends Schema.TaggedError()("RunNotFoundError", { message: Schema.String }, { httpApiStatus: 404 }) {
243
243
  }
244
- export class RunInternalServerError extends Schema.TaggedErrorClass()("RunInternalServerError", { message: Schema.String }, { httpApiStatus: 500 }) {
244
+ export class RunInternalServerError extends Schema.TaggedError()("RunInternalServerError", { message: Schema.String }, { httpApiStatus: 500 }) {
245
245
  }
246
246
  const runIdParams = Schema.Struct({ runId: NonEmptyString });
247
247
  const runEventParams = Schema.Struct({ runId: NonEmptyString, sequence: NonEmptyString });
package/dist/core-api/sessions.d.ts CHANGED
@@ -14,7 +14,7 @@
14
14
  * (create/close). Without a bearer token the pre-auth owner model applies unchanged.
15
15
  */
16
16
  import { Schema } from "effect";
17
- import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
17
+ import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
18
18
  export declare const sessionStatusSchema: Schema.Literals<readonly ["starting", "running", "exited", "failed"]>;
19
19
  export type SessionStatusWire = typeof sessionStatusSchema.Type;
20
20
  export declare const sessionAuthorizationHeadersSchema: Schema.Struct<{
@@ -301,13 +301,13 @@ declare const SessionInternalServerError_base: Schema.Class<SessionInternalServe
301
301
  }>, import("effect/Cause").YieldableError>;
302
302
  export declare class SessionInternalServerError extends SessionInternalServerError_base {
303
303
  }
304
- export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpApiEndpoint.HttpApiEndpoint<"closeSession", "POST", "/:sessionId/close", HttpApiEndpoint.StringTree<Schema.Struct<{
304
+ export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpApiEndpoint.HttpApiEndpoint<"closeSession", "POST", "/:sessionId/close", Schema.toCodecStringTree<Schema.Struct<{
305
305
  readonly sessionId: Schema.String;
306
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
306
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
307
307
  readonly ownerUserId: Schema.optional<Schema.String>;
308
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
308
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
309
309
  readonly authorization: Schema.optional<Schema.String>;
310
- }>>, HttpApiEndpoint.Json<Schema.Struct<{
310
+ }>>, Schema.toCodecJson<Schema.Struct<{
311
311
  readonly sessionId: Schema.String;
312
312
  readonly workspaceId: Schema.String;
313
313
  /** The interactive run recording this session; its record is the durable evidence. */
@@ -340,7 +340,7 @@ export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpAp
340
340
  readonly outputHighWater: Schema.String;
341
341
  readonly createdAt: Schema.String;
342
342
  readonly endedAt: Schema.optional<Schema.String>;
343
- }>>, HttpApiEndpoint.Json<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"createSession", "POST", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
343
+ }>>, Schema.toCodecJson<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"createSession", "POST", "/", never, never, Schema.toCodecJson<Schema.Struct<{
344
344
  readonly workspaceId: Schema.String;
345
345
  readonly ownerUserId: Schema.String;
346
346
  /**
@@ -365,9 +365,9 @@ export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpAp
365
365
  * that cannot run one answers `404`, so a mixed-version fleet never runs it as root.
366
366
  */
367
367
  readonly user: Schema.optional<Schema.String>;
368
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
368
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
369
369
  readonly authorization: Schema.optional<Schema.String>;
370
- }>>, HttpApiEndpoint.Json<Schema.Struct<{
370
+ }>>, Schema.toCodecJson<Schema.Struct<{
371
371
  readonly sessionId: Schema.String;
372
372
  readonly workspaceId: Schema.String;
373
373
  /** The interactive run recording this session; its record is the durable evidence. */
@@ -400,7 +400,7 @@ export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpAp
400
400
  readonly outputHighWater: Schema.String;
401
401
  readonly createdAt: Schema.String;
402
402
  readonly endedAt: Schema.optional<Schema.String>;
403
- }>>, HttpApiEndpoint.Json<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionConflictError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"createSessionAsUser", "POST", "/as-user", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
403
+ }>>, Schema.toCodecJson<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionConflictError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"createSessionAsUser", "POST", "/as-user", never, never, Schema.toCodecJson<Schema.Struct<{
404
404
  readonly workspaceId: Schema.String;
405
405
  readonly ownerUserId: Schema.String;
406
406
  /**
@@ -420,9 +420,9 @@ export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpAp
420
420
  /** Opaque caller correlation bag: stored verbatim, echoed on reads, no platform semantics. */
421
421
  readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
422
422
  readonly user: Schema.String;
423
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
423
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
424
424
  readonly authorization: Schema.optional<Schema.String>;
425
- }>>, HttpApiEndpoint.Json<Schema.Struct<{
425
+ }>>, Schema.toCodecJson<Schema.Struct<{
426
426
  readonly sessionId: Schema.String;
427
427
  readonly workspaceId: Schema.String;
428
428
  /** The interactive run recording this session; its record is the durable evidence. */
@@ -455,13 +455,13 @@ export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpAp
455
455
  readonly outputHighWater: Schema.String;
456
456
  readonly createdAt: Schema.String;
457
457
  readonly endedAt: Schema.optional<Schema.String>;
458
- }>>, HttpApiEndpoint.Json<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionConflictError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getSession", "GET", "/:sessionId", HttpApiEndpoint.StringTree<Schema.Struct<{
458
+ }>>, Schema.toCodecJson<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionConflictError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getSession", "GET", "/:sessionId", Schema.toCodecStringTree<Schema.Struct<{
459
459
  readonly sessionId: Schema.String;
460
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
460
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
461
461
  readonly ownerUserId: Schema.optional<Schema.String>;
462
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
462
+ }>>, never, Schema.toCodecStringTree<Schema.Struct<{
463
463
  readonly authorization: Schema.optional<Schema.String>;
464
- }>>, HttpApiEndpoint.Json<Schema.Struct<{
464
+ }>>, Schema.toCodecJson<Schema.Struct<{
465
465
  readonly sessionId: Schema.String;
466
466
  readonly workspaceId: Schema.String;
467
467
  /** The interactive run recording this session; its record is the durable evidence. */
@@ -494,15 +494,15 @@ export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpAp
494
494
  readonly outputHighWater: Schema.String;
495
495
  readonly createdAt: Schema.String;
496
496
  readonly endedAt: Schema.optional<Schema.String>;
497
- }>>, HttpApiEndpoint.Json<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getSessionOutput", "GET", "/:sessionId/output", HttpApiEndpoint.StringTree<Schema.Struct<{
497
+ }>>, Schema.toCodecJson<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getSessionOutput", "GET", "/:sessionId/output", Schema.toCodecStringTree<Schema.Struct<{
498
498
  readonly sessionId: Schema.String;
499
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
499
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
500
500
  readonly ownerUserId: Schema.optional<Schema.String>;
501
501
  readonly from: Schema.optional<Schema.String>;
502
502
  readonly limit: Schema.optional<Schema.String>;
503
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
503
+ }>>, never, Schema.toCodecStringTree<Schema.Struct<{
504
504
  readonly authorization: Schema.optional<Schema.String>;
505
- }>>, HttpApiEndpoint.Json<Schema.Struct<{
505
+ }>>, Schema.toCodecJson<Schema.Struct<{
506
506
  readonly sessionId: Schema.String;
507
507
  readonly chunks: Schema.$Array<Schema.Struct<{
508
508
  readonly sequence: Schema.String;
@@ -513,14 +513,14 @@ export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpAp
513
513
  readonly nextFrom: Schema.String;
514
514
  /** Session status at read time, so pollers can stop when the session settles. */
515
515
  readonly status: Schema.Literals<readonly ["starting", "running", "exited", "failed"]>;
516
- }>>, HttpApiEndpoint.Json<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listSessions", "GET", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
516
+ }>>, Schema.toCodecJson<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listSessions", "GET", "/", never, Schema.toCodecStringTree<Schema.Struct<{
517
517
  readonly ownerUserId: Schema.String;
518
518
  readonly workspaceId: Schema.optional<Schema.String>;
519
519
  readonly status: Schema.optional<Schema.Literals<readonly ["starting", "running", "exited", "failed"]>>;
520
520
  readonly limit: Schema.optional<Schema.String>;
521
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
521
+ }>>, never, Schema.toCodecStringTree<Schema.Struct<{
522
522
  readonly authorization: Schema.optional<Schema.String>;
523
- }>>, HttpApiEndpoint.Json<Schema.Struct<{
523
+ }>>, Schema.toCodecJson<Schema.Struct<{
524
524
  readonly items: Schema.$Array<Schema.Struct<{
525
525
  readonly sessionId: Schema.String;
526
526
  readonly workspaceId: Schema.String;
@@ -555,35 +555,35 @@ export declare const SessionsGroup: HttpApiGroup.HttpApiGroup<"sessions", HttpAp
555
555
  readonly createdAt: Schema.String;
556
556
  readonly endedAt: Schema.optional<Schema.String>;
557
557
  }>>;
558
- }>>, HttpApiEndpoint.Json<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"resizeSession", "POST", "/:sessionId/resize", HttpApiEndpoint.StringTree<Schema.Struct<{
558
+ }>>, Schema.toCodecJson<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"resizeSession", "POST", "/:sessionId/resize", Schema.toCodecStringTree<Schema.Struct<{
559
559
  readonly sessionId: Schema.String;
560
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
560
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
561
561
  readonly ownerUserId: Schema.optional<Schema.String>;
562
562
  readonly cols: Schema.Int;
563
563
  readonly rows: Schema.Int;
564
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
564
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
565
565
  readonly authorization: Schema.optional<Schema.String>;
566
- }>>, HttpApiEndpoint.Json<Schema.Struct<{
566
+ }>>, Schema.toCodecJson<Schema.Struct<{
567
567
  readonly ok: Schema.Boolean;
568
- }>>, HttpApiEndpoint.Json<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionConflictError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"sendSessionInput", "POST", "/:sessionId/input", HttpApiEndpoint.StringTree<Schema.Struct<{
568
+ }>>, Schema.toCodecJson<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionConflictError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"sendSessionInput", "POST", "/:sessionId/input", Schema.toCodecStringTree<Schema.Struct<{
569
569
  readonly sessionId: Schema.String;
570
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
570
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
571
571
  readonly ownerUserId: Schema.optional<Schema.String>;
572
572
  /** Base64-encoded keystrokes (bytes, not text — binary-safe). */
573
573
  readonly dataBase64: Schema.String;
574
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
574
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
575
575
  readonly authorization: Schema.optional<Schema.String>;
576
- }>>, HttpApiEndpoint.Json<Schema.Struct<{
576
+ }>>, Schema.toCodecJson<Schema.Struct<{
577
577
  readonly ok: Schema.Boolean;
578
- }>>, HttpApiEndpoint.Json<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionConflictError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"signalSession", "POST", "/:sessionId/signal", HttpApiEndpoint.StringTree<Schema.Struct<{
578
+ }>>, Schema.toCodecJson<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionConflictError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"signalSession", "POST", "/:sessionId/signal", Schema.toCodecStringTree<Schema.Struct<{
579
579
  readonly sessionId: Schema.String;
580
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
580
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
581
581
  readonly ownerUserId: Schema.optional<Schema.String>;
582
582
  /** POSIX signal number (e.g. 2 = SIGINT, 15 = SIGTERM). */
583
583
  readonly signal: Schema.Int;
584
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
584
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
585
585
  readonly authorization: Schema.optional<Schema.String>;
586
- }>>, HttpApiEndpoint.Json<Schema.Struct<{
586
+ }>>, Schema.toCodecJson<Schema.Struct<{
587
587
  readonly ok: Schema.Boolean;
588
- }>>, HttpApiEndpoint.Json<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionConflictError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never>, false>;
588
+ }>>, Schema.toCodecJson<typeof SessionBadRequestError | typeof SessionUnauthorizedError | typeof SessionForbiddenError | typeof SessionNotFoundError | typeof SessionConflictError | typeof SessionBadGatewayError | typeof SessionInternalServerError>, never, never>, false>;
589
589
  export {};
package/dist/core-api/sessions.js CHANGED
@@ -14,7 +14,7 @@
14
14
  * (create/close). Without a bearer token the pre-auth owner model applies unchanged.
15
15
  */
16
16
  import { Schema } from "effect";
17
- import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
17
+ import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
18
18
  const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
19
19
  export const sessionStatusSchema = Schema.Literals(["starting", "running", "exited", "failed"]);
20
20
  export const sessionAuthorizationHeadersSchema = Schema.Struct({
@@ -230,23 +230,23 @@ export const sessionOutputResponseSchema = Schema.Struct({
230
230
  /** Session status at read time, so pollers can stop when the session settles. */
231
231
  status: sessionStatusSchema,
232
232
  });
233
- export class SessionBadRequestError extends Schema.TaggedErrorClass()("SessionBadRequestError", { message: Schema.String }, { httpApiStatus: 400 }) {
233
+ export class SessionBadRequestError extends Schema.TaggedError()("SessionBadRequestError", { message: Schema.String }, { httpApiStatus: 400 }) {
234
234
  }
235
- export class SessionUnauthorizedError extends Schema.TaggedErrorClass()("SessionUnauthorizedError", { message: Schema.String }, { httpApiStatus: 401 }) {
235
+ export class SessionUnauthorizedError extends Schema.TaggedError()("SessionUnauthorizedError", { message: Schema.String }, { httpApiStatus: 401 }) {
236
236
  }
237
- export class SessionForbiddenError extends Schema.TaggedErrorClass()("SessionForbiddenError", { message: Schema.String }, { httpApiStatus: 403 }) {
237
+ export class SessionForbiddenError extends Schema.TaggedError()("SessionForbiddenError", { message: Schema.String }, { httpApiStatus: 403 }) {
238
238
  }
239
- export class SessionNotFoundError extends Schema.TaggedErrorClass()("SessionNotFoundError", { message: Schema.String }, { httpApiStatus: 404 }) {
239
+ export class SessionNotFoundError extends Schema.TaggedError()("SessionNotFoundError", { message: Schema.String }, { httpApiStatus: 404 }) {
240
240
  }
241
- export class SessionConflictError extends Schema.TaggedErrorClass()("SessionConflictError", {
241
+ export class SessionConflictError extends Schema.TaggedError()("SessionConflictError", {
242
242
  message: Schema.String,
243
243
  /** A stable reason, where one applies (`user-unsupported`). */
244
244
  code: Schema.optional(NonEmptyString),
245
245
  }, { httpApiStatus: 409 }) {
246
246
  }
247
- export class SessionBadGatewayError extends Schema.TaggedErrorClass()("SessionBadGatewayError", { message: Schema.String }, { httpApiStatus: 502 }) {
247
+ export class SessionBadGatewayError extends Schema.TaggedError()("SessionBadGatewayError", { message: Schema.String }, { httpApiStatus: 502 }) {
248
248
  }
249
- export class SessionInternalServerError extends Schema.TaggedErrorClass()("SessionInternalServerError", { message: Schema.String }, { httpApiStatus: 500 }) {
249
+ export class SessionInternalServerError extends Schema.TaggedError()("SessionInternalServerError", { message: Schema.String }, { httpApiStatus: 500 }) {
250
250
  }
251
251
  const sessionIdParams = Schema.Struct({ sessionId: NonEmptyString });
252
252
  export const SessionsGroup = HttpApiGroup.make("sessions")
package/dist/core-api/ssh-keys.d.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  import { Schema } from "effect";
2
- import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
2
+ import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
3
3
  export declare const sshKeyGatewayHeadersSchema: Schema.Struct<{
4
4
  readonly "x-sealant-gateway-token": Schema.optional<Schema.String>;
5
5
  }>;
@@ -74,31 +74,31 @@ declare const SshKeyInternalServerError_base: Schema.Class<SshKeyInternalServerE
74
74
  }>, import("effect/Cause").YieldableError>;
75
75
  export declare class SshKeyInternalServerError extends SshKeyInternalServerError_base {
76
76
  }
77
- export declare const SshKeysGroup: HttpApiGroup.HttpApiGroup<"sshKeys", HttpApiEndpoint.HttpApiEndpoint<"archiveSshKey", "DELETE", "/:sshKeyId", HttpApiEndpoint.StringTree<Schema.Struct<{
77
+ export declare const SshKeysGroup: HttpApiGroup.HttpApiGroup<"sshKeys", HttpApiEndpoint.HttpApiEndpoint<"archiveSshKey", "DELETE", "/:sshKeyId", Schema.toCodecStringTree<Schema.Struct<{
78
78
  readonly sshKeyId: Schema.String;
79
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
79
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
80
80
  readonly ownerUserId: Schema.String;
81
- }>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
81
+ }>>, never, never, Schema.toCodecJson<Schema.Struct<{
82
82
  readonly sshKeyId: Schema.String;
83
83
  readonly ownerUserId: Schema.String;
84
84
  readonly name: Schema.String;
85
85
  readonly algorithm: Schema.String;
86
86
  readonly fingerprint: Schema.String;
87
87
  readonly createdAt: Schema.String;
88
- }>>, HttpApiEndpoint.Json<typeof SshKeyNotFoundError | typeof SshKeyInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"createSshKey", "POST", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
88
+ }>>, Schema.toCodecJson<typeof SshKeyNotFoundError | typeof SshKeyInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"createSshKey", "POST", "/", never, never, Schema.toCodecJson<Schema.Struct<{
89
89
  readonly ownerUserId: Schema.String;
90
90
  readonly name: Schema.optional<Schema.String>;
91
91
  readonly publicKey: Schema.String;
92
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
92
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
93
93
  readonly sshKeyId: Schema.String;
94
94
  readonly ownerUserId: Schema.String;
95
95
  readonly name: Schema.String;
96
96
  readonly algorithm: Schema.String;
97
97
  readonly fingerprint: Schema.String;
98
98
  readonly createdAt: Schema.String;
99
- }>>, HttpApiEndpoint.Json<typeof SshKeyBadRequestError | typeof SshKeyNotFoundError | typeof SshKeyConflictError | typeof SshKeyInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listSshKeys", "GET", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
99
+ }>>, Schema.toCodecJson<typeof SshKeyBadRequestError | typeof SshKeyNotFoundError | typeof SshKeyConflictError | typeof SshKeyInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listSshKeys", "GET", "/", never, Schema.toCodecStringTree<Schema.Struct<{
100
100
  readonly ownerUserId: Schema.String;
101
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
101
+ }>>, never, never, Schema.toCodecJson<Schema.Struct<{
102
102
  readonly items: Schema.$Array<Schema.Struct<{
103
103
  readonly sshKeyId: Schema.String;
104
104
  readonly ownerUserId: Schema.String;
@@ -107,14 +107,14 @@ export declare const SshKeysGroup: HttpApiGroup.HttpApiGroup<"sshKeys", HttpApiE
107
107
  readonly fingerprint: Schema.String;
108
108
  readonly createdAt: Schema.String;
109
109
  }>>;
110
- }>>, HttpApiEndpoint.Json<typeof SshKeyInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"resolveSshPrincipal", "POST", "/resolve-principal", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
110
+ }>>, Schema.toCodecJson<typeof SshKeyInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"resolveSshPrincipal", "POST", "/resolve-principal", never, never, Schema.toCodecJson<Schema.Struct<{
111
111
  readonly algo: Schema.String;
112
112
  readonly publicKeyBase64: Schema.String;
113
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
113
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
114
114
  readonly "x-sealant-gateway-token": Schema.optional<Schema.String>;
115
- }>>, HttpApiEndpoint.Json<Schema.Struct<{
115
+ }>>, Schema.toCodecJson<Schema.Struct<{
116
116
  readonly principalId: Schema.String;
117
117
  readonly sshKeyId: Schema.String;
118
118
  readonly fingerprint: Schema.String;
119
- }>>, HttpApiEndpoint.Json<typeof SshKeyUnauthorizedError | typeof SshKeyNotFoundError | typeof SshKeyServiceUnavailableError | typeof SshKeyInternalServerError>, never, never>, false>;
119
+ }>>, Schema.toCodecJson<typeof SshKeyUnauthorizedError | typeof SshKeyNotFoundError | typeof SshKeyServiceUnavailableError | typeof SshKeyInternalServerError>, never, never>, false>;
120
120
  export {};
package/dist/core-api/ssh-keys.js CHANGED
@@ -1,5 +1,5 @@
1
1
  import { Schema } from "effect";
2
- import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
2
+ import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
3
3
  const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
4
4
  /*
5
5
  User SSH public keys. Two audiences:
@@ -45,27 +45,27 @@ export const resolveSshPrincipalResponseSchema = Schema.Struct({
45
45
  sshKeyId: NonEmptyString,
46
46
  fingerprint: NonEmptyString,
47
47
  });
48
- export class SshKeyBadRequestError extends Schema.TaggedErrorClass()("SshKeyBadRequestError", {
48
+ export class SshKeyBadRequestError extends Schema.TaggedError()("SshKeyBadRequestError", {
49
49
  message: Schema.String,
50
50
  }, { httpApiStatus: 400 }) {
51
51
  }
52
- export class SshKeyUnauthorizedError extends Schema.TaggedErrorClass()("SshKeyUnauthorizedError", {
52
+ export class SshKeyUnauthorizedError extends Schema.TaggedError()("SshKeyUnauthorizedError", {
53
53
  message: Schema.String,
54
54
  }, { httpApiStatus: 401 }) {
55
55
  }
56
- export class SshKeyNotFoundError extends Schema.TaggedErrorClass()("SshKeyNotFoundError", {
56
+ export class SshKeyNotFoundError extends Schema.TaggedError()("SshKeyNotFoundError", {
57
57
  message: Schema.String,
58
58
  }, { httpApiStatus: 404 }) {
59
59
  }
60
- export class SshKeyConflictError extends Schema.TaggedErrorClass()("SshKeyConflictError", {
60
+ export class SshKeyConflictError extends Schema.TaggedError()("SshKeyConflictError", {
61
61
  message: Schema.String,
62
62
  }, { httpApiStatus: 409 }) {
63
63
  }
64
- export class SshKeyServiceUnavailableError extends Schema.TaggedErrorClass()("SshKeyServiceUnavailableError", {
64
+ export class SshKeyServiceUnavailableError extends Schema.TaggedError()("SshKeyServiceUnavailableError", {
65
65
  message: Schema.String,
66
66
  }, { httpApiStatus: 503 }) {
67
67
  }
68
- export class SshKeyInternalServerError extends Schema.TaggedErrorClass()("SshKeyInternalServerError", {
68
+ export class SshKeyInternalServerError extends Schema.TaggedError()("SshKeyInternalServerError", {
69
69
  message: Schema.String,
70
70
  }, { httpApiStatus: 500 }) {
71
71
  }
package/dist/core-api/system.d.ts CHANGED
@@ -1,5 +1,5 @@
1
1
  import { Schema } from "effect";
2
- import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
2
+ import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
3
3
  export declare const systemIndexResponseSchema: Schema.Struct<{
4
4
  readonly name: Schema.String;
5
5
  readonly version: Schema.String;
@@ -73,7 +73,7 @@ declare const SystemInternalServerError_base: Schema.Class<SystemInternalServerE
73
73
  }>, import("effect/Cause").YieldableError>;
74
74
  export declare class SystemInternalServerError extends SystemInternalServerError_base {
75
75
  }
76
- export declare const SystemGroup: HttpApiGroup.HttpApiGroup<"system", HttpApiEndpoint.HttpApiEndpoint<"getIndex", "GET", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
76
+ export declare const SystemGroup: HttpApiGroup.HttpApiGroup<"system", HttpApiEndpoint.HttpApiEndpoint<"getIndex", "GET", "/", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
77
77
  readonly name: Schema.String;
78
78
  readonly version: Schema.String;
79
79
  readonly docsPath: Schema.String;
@@ -120,16 +120,16 @@ export declare const SystemGroup: HttpApiGroup.HttpApiGroup<"system", HttpApiEnd
120
120
  */
121
121
  readonly sshKeyRemovalEndsConnections: Schema.optional<Schema.Boolean>;
122
122
  }>>;
123
- }>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getSetupState", "GET", "/v1/system/setup-state", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
123
+ }>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getSetupState", "GET", "/v1/system/setup-state", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
124
124
  readonly needsSetup: Schema.Boolean;
125
125
  readonly sshGateway: Schema.NullOr<Schema.Struct<{
126
126
  readonly host: Schema.String;
127
127
  readonly port: Schema.Number;
128
128
  readonly usernamePrefix: Schema.String;
129
129
  }>>;
130
- }>>, HttpApiEndpoint.Json<typeof SystemInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"health", "GET", "/healthz", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
130
+ }>>, Schema.toCodecJson<typeof SystemInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"health", "GET", "/healthz", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
131
131
  readonly status: Schema.Literal<"ok">;
132
- }>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"ready", "GET", "/readyz", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
132
+ }>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"ready", "GET", "/readyz", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
133
133
  readonly status: Schema.Literal<"ok">;
134
- }>>, HttpApiEndpoint.Json<never>, never, never>, false>;
134
+ }>>, never, never, never>, false>;
135
135
  export {};
package/dist/core-api/system.js CHANGED
@@ -1,5 +1,5 @@
1
1
  import { Schema } from "effect";
2
- import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
2
+ import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
3
3
  const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
4
4
  export const systemIndexResponseSchema = Schema.Struct({
5
5
  name: NonEmptyString,
@@ -65,7 +65,7 @@ export const setupStateResponseSchema = Schema.Struct({
65
65
  // Null when WORKSPACE_SSH_GATEWAY_HOST is not configured on the API.
66
66
  sshGateway: Schema.NullOr(setupStateSshGatewaySchema),
67
67
  });
68
- export class SystemInternalServerError extends Schema.TaggedErrorClass()("SystemInternalServerError", {
68
+ export class SystemInternalServerError extends Schema.TaggedError()("SystemInternalServerError", {
69
69
  message: Schema.String,
70
70
  }, { httpApiStatus: 500 }) {
71
71
  }