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

package/dist/core-api/access-tokens.d.ts

@@ -8,7 +8,7 @@
  * the scopes is DOWNSTREAM enforcement (a leaked read-stream token cannot send input or exec).
  */
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 export declare const accessTokenScopeSchema: Schema.Literals<readonly ["session:read", "session:input", "workspace:exec"]>;
 export type AccessTokenScopeWire = typeof accessTokenScopeSchema.Type;
 export declare const createAccessTokenRequestSchema: Schema.Struct<{
@@ -77,7 +77,7 @@ declare const AccessTokenInternalServerError_base: Schema.Class<AccessTokenInter
 }>, import("effect/Cause").YieldableError>;
 export declare class AccessTokenInternalServerError extends AccessTokenInternalServerError_base {
 }
-export declare const AccessTokensGroup: HttpApiGroup.HttpApiGroup<"accessTokens", HttpApiEndpoint.HttpApiEndpoint<"createAccessToken", "POST", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+export declare const AccessTokensGroup: HttpApiGroup.HttpApiGroup<"accessTokens", HttpApiEndpoint.HttpApiEndpoint<"createAccessToken", "POST", "/", never, never, Schema.toCodecJson<Schema.Struct<{
     readonly ownerUserId: Schema.String;
     readonly scopes: Schema.$Array<Schema.Literals<readonly ["session:read", "session:input", "workspace:exec"]>>;
     readonly name: Schema.optional<Schema.String>;
@@ -85,7 +85,7 @@ export declare const AccessTokensGroup: HttpApiGroup.HttpApiGroup<"accessTokens"
     readonly workspaceId: Schema.optional<Schema.String>;
     /** Seconds until the token expires; omitted = no expiry. */
     readonly ttlSeconds: Schema.optional<Schema.Int>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly tokenId: Schema.String;
     readonly ownerUserId: Schema.String;
     readonly name: Schema.optional<Schema.String>;
@@ -96,9 +96,9 @@ export declare const AccessTokensGroup: HttpApiGroup.HttpApiGroup<"accessTokens"
     readonly createdAt: Schema.String;
     /** The bearer secret (`slt_...`). Shown exactly once — it is never stored or retrievable. */
     readonly token: Schema.String;
-}>>, HttpApiEndpoint.Json<typeof AccessTokenBadRequestError | typeof AccessTokenNotFoundError | typeof AccessTokenInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listAccessTokens", "GET", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof AccessTokenBadRequestError | typeof AccessTokenNotFoundError | typeof AccessTokenInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listAccessTokens", "GET", "/", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly ownerUserId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly items: Schema.$Array<Schema.Struct<{
         readonly tokenId: Schema.String;
         readonly ownerUserId: Schema.String;
@@ -109,11 +109,11 @@ export declare const AccessTokensGroup: HttpApiGroup.HttpApiGroup<"accessTokens"
         readonly revokedAt: Schema.optional<Schema.String>;
         readonly createdAt: Schema.String;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof AccessTokenBadRequestError | typeof AccessTokenInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"revokeAccessToken", "POST", "/:tokenId/revoke", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof AccessTokenBadRequestError | typeof AccessTokenInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"revokeAccessToken", "POST", "/:tokenId/revoke", Schema.toCodecStringTree<Schema.Struct<{
     readonly tokenId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly ownerUserId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly tokenId: Schema.String;
     readonly ownerUserId: Schema.String;
     readonly name: Schema.optional<Schema.String>;
@@ -122,5 +122,5 @@ export declare const AccessTokensGroup: HttpApiGroup.HttpApiGroup<"accessTokens"
     readonly expiresAt: Schema.optional<Schema.String>;
     readonly revokedAt: Schema.optional<Schema.String>;
     readonly createdAt: Schema.String;
-}>>, HttpApiEndpoint.Json<typeof AccessTokenBadRequestError | typeof AccessTokenNotFoundError | typeof AccessTokenInternalServerError>, never, never>, false>;
+}>>, Schema.toCodecJson<typeof AccessTokenBadRequestError | typeof AccessTokenNotFoundError | typeof AccessTokenInternalServerError>, never, never>, false>;
 export {};

package/dist/core-api/access-tokens.js

@@ -8,7 +8,7 @@
  * the scopes is DOWNSTREAM enforcement (a leaked read-stream token cannot send input or exec).
  */
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
 export const accessTokenScopeSchema = Schema.Literals([
     "session:read",
@@ -45,11 +45,11 @@ export const listAccessTokensQuerySchema = Schema.Struct({
 export const listAccessTokensResponseSchema = Schema.Struct({
     items: Schema.Array(accessTokenSchema),
 });
-export class AccessTokenBadRequestError extends Schema.TaggedErrorClass()("AccessTokenBadRequestError", { message: Schema.String }, { httpApiStatus: 400 }) {
+export class AccessTokenBadRequestError extends Schema.TaggedError()("AccessTokenBadRequestError", { message: Schema.String }, { httpApiStatus: 400 }) {
 }
-export class AccessTokenNotFoundError extends Schema.TaggedErrorClass()("AccessTokenNotFoundError", { message: Schema.String }, { httpApiStatus: 404 }) {
+export class AccessTokenNotFoundError extends Schema.TaggedError()("AccessTokenNotFoundError", { message: Schema.String }, { httpApiStatus: 404 }) {
 }
-export class AccessTokenInternalServerError extends Schema.TaggedErrorClass()("AccessTokenInternalServerError", { message: Schema.String }, { httpApiStatus: 500 }) {
+export class AccessTokenInternalServerError extends Schema.TaggedError()("AccessTokenInternalServerError", { message: Schema.String }, { httpApiStatus: 500 }) {
 }
 const tokenIdParams = Schema.Struct({ tokenId: NonEmptyString });
 export const AccessTokensGroup = HttpApiGroup.make("accessTokens")

package/dist/core-api/budgets.js

@@ -4,7 +4,7 @@ import { Schema } from "effect";
  * limit, `retryAfterSeconds` when there is room again: the rest of a rate window, or an estimate
  * for a concurrency ceiling that only frees when the owner's own work settles.
  */
-export class BudgetExceededError extends Schema.TaggedErrorClass()("BudgetExceededError", {
+export class BudgetExceededError extends Schema.TaggedError()("BudgetExceededError", {
     message: Schema.String,
     budget: Schema.String,
     limit: Schema.Number,

package/dist/core-api/connected-accounts.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 export declare const connectedAccountProviderSchema: Schema.Literals<readonly ["claude", "codex", "github"]>;
 export type ConnectedAccountProvider = typeof connectedAccountProviderSchema.Type;
 export declare const connectedAccountStatusSchema: Schema.Literals<readonly ["active", "invalid", "archived"]>;
@@ -113,11 +113,11 @@ declare const ConnectedAccountInternalServerError_base: Schema.Class<ConnectedAc
 }>, import("effect/Cause").YieldableError>;
 export declare class ConnectedAccountInternalServerError extends ConnectedAccountInternalServerError_base {
 }
-export declare const ConnectedAccountsGroup: HttpApiGroup.HttpApiGroup<"connectedAccounts", HttpApiEndpoint.HttpApiEndpoint<"archiveConnectedAccount", "DELETE", "/:connectedAccountId", HttpApiEndpoint.StringTree<Schema.Struct<{
+export declare const ConnectedAccountsGroup: HttpApiGroup.HttpApiGroup<"connectedAccounts", HttpApiEndpoint.HttpApiEndpoint<"archiveConnectedAccount", "DELETE", "/:connectedAccountId", Schema.toCodecStringTree<Schema.Struct<{
     readonly connectedAccountId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly ownerUserId: Schema.String;
-}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly connectedAccountId: Schema.String;
     readonly ownerUserId: Schema.String;
     readonly provider: Schema.Literals<readonly ["claude", "codex", "github"]>;
@@ -140,12 +140,12 @@ export declare const ConnectedAccountsGroup: HttpApiGroup.HttpApiGroup<"connecte
         /** What that attempt did: `refreshed`, `fresh` (nothing to do), or `failed`. */
         readonly lastRefreshOutcome: Schema.NullOr<Schema.Literals<readonly ["refreshed", "fresh", "failed"]>>;
     }>;
-}>>, HttpApiEndpoint.Json<typeof ConnectedAccountNotFoundError | typeof ConnectedAccountInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"createConnectedAccount", "POST", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof ConnectedAccountNotFoundError | typeof ConnectedAccountInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"createConnectedAccount", "POST", "/", never, never, Schema.toCodecJson<Schema.Struct<{
     readonly ownerUserId: Schema.String;
     readonly provider: Schema.Literals<readonly ["claude", "codex", "github"]>;
     readonly name: Schema.optional<Schema.String>;
     readonly secret: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly connectedAccountId: Schema.String;
     readonly ownerUserId: Schema.String;
     readonly provider: Schema.Literals<readonly ["claude", "codex", "github"]>;
@@ -168,9 +168,9 @@ export declare const ConnectedAccountsGroup: HttpApiGroup.HttpApiGroup<"connecte
         /** What that attempt did: `refreshed`, `fresh` (nothing to do), or `failed`. */
         readonly lastRefreshOutcome: Schema.NullOr<Schema.Literals<readonly ["refreshed", "fresh", "failed"]>>;
     }>;
-}>>, HttpApiEndpoint.Json<typeof ConnectedAccountBadRequestError | typeof ConnectedAccountNotFoundError | typeof ConnectedAccountConflictError | typeof ConnectedAccountServiceUnavailableError | typeof ConnectedAccountInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listConnectedAccounts", "GET", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof ConnectedAccountBadRequestError | typeof ConnectedAccountNotFoundError | typeof ConnectedAccountConflictError | typeof ConnectedAccountServiceUnavailableError | typeof ConnectedAccountInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listConnectedAccounts", "GET", "/", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly ownerUserId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly items: Schema.$Array<Schema.Struct<{
         readonly connectedAccountId: Schema.String;
         readonly ownerUserId: Schema.String;
@@ -195,11 +195,11 @@ export declare const ConnectedAccountsGroup: HttpApiGroup.HttpApiGroup<"connecte
             readonly lastRefreshOutcome: Schema.NullOr<Schema.Literals<readonly ["refreshed", "fresh", "failed"]>>;
         }>;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof ConnectedAccountInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"markConnectedAccountInvalid", "POST", "/:connectedAccountId/mark-invalid", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof ConnectedAccountInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"markConnectedAccountInvalid", "POST", "/:connectedAccountId/mark-invalid", Schema.toCodecStringTree<Schema.Struct<{
     readonly connectedAccountId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly ownerUserId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly connectedAccountId: Schema.String;
     readonly ownerUserId: Schema.String;
     readonly provider: Schema.Literals<readonly ["claude", "codex", "github"]>;
@@ -222,5 +222,5 @@ export declare const ConnectedAccountsGroup: HttpApiGroup.HttpApiGroup<"connecte
         /** What that attempt did: `refreshed`, `fresh` (nothing to do), or `failed`. */
         readonly lastRefreshOutcome: Schema.NullOr<Schema.Literals<readonly ["refreshed", "fresh", "failed"]>>;
     }>;
-}>>, HttpApiEndpoint.Json<typeof ConnectedAccountNotFoundError | typeof ConnectedAccountInternalServerError>, never, never>, false>;
+}>>, Schema.toCodecJson<typeof ConnectedAccountNotFoundError | typeof ConnectedAccountInternalServerError>, never, never>, false>;
 export {};

package/dist/core-api/connected-accounts.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
 /*
 Connected provider accounts (Claude / Codex / GitHub credentials). Same trust model as ssh-keys:
@@ -67,23 +67,23 @@ export const listConnectedAccountsResponseSchema = Schema.Struct({
 export const markConnectedAccountInvalidRequestSchema = Schema.Struct({
     ownerUserId: NonEmptyString,
 });
-export class ConnectedAccountBadRequestError extends Schema.TaggedErrorClass()("ConnectedAccountBadRequestError", {
+export class ConnectedAccountBadRequestError extends Schema.TaggedError()("ConnectedAccountBadRequestError", {
     message: Schema.String,
 }, { httpApiStatus: 400 }) {
 }
-export class ConnectedAccountNotFoundError extends Schema.TaggedErrorClass()("ConnectedAccountNotFoundError", {
+export class ConnectedAccountNotFoundError extends Schema.TaggedError()("ConnectedAccountNotFoundError", {
     message: Schema.String,
 }, { httpApiStatus: 404 }) {
 }
-export class ConnectedAccountConflictError extends Schema.TaggedErrorClass()("ConnectedAccountConflictError", {
+export class ConnectedAccountConflictError extends Schema.TaggedError()("ConnectedAccountConflictError", {
     message: Schema.String,
 }, { httpApiStatus: 409 }) {
 }
-export class ConnectedAccountServiceUnavailableError extends Schema.TaggedErrorClass()("ConnectedAccountServiceUnavailableError", {
+export class ConnectedAccountServiceUnavailableError extends Schema.TaggedError()("ConnectedAccountServiceUnavailableError", {
     message: Schema.String,
 }, { httpApiStatus: 503 }) {
 }
-export class ConnectedAccountInternalServerError extends Schema.TaggedErrorClass()("ConnectedAccountInternalServerError", {
+export class ConnectedAccountInternalServerError extends Schema.TaggedError()("ConnectedAccountInternalServerError", {
     message: Schema.String,
 }, { httpApiStatus: 500 }) {
 }