@composio/client 2.0.0-rc.11 → 2.0.0-rc.12

package/README.md

@@ -2,7 +2,7 @@
 
 Composio API client for TypeScript, generated from the [v3.1 OpenAPI spec](https://staging-backend.composio.dev/api/v3.1/openapi.json) with [hey-api](https://heyapi.dev).
 
-This repo is the successor to the Stainless-generated [`@composio/client`](https://www.npmjs.com/package/@composio/client) (Stainless is sunsetting). Current scope: the full `/api/v3.1` surface — all 104 released operations — in **both** languages: TypeScript at the package root, and Python in [`python/`](./python/README.md) (PyPI takeover pending). Migration is tracked on the wayfinder map [UXE-152](https://linear.app/composio/issue/UXE-152).
+This repo is the successor to the Stainless-generated [`@composio/client`](https://www.npmjs.com/package/@composio/client) (Stainless is sunsetting). Current scope: the full `/api/v3.1` surface — all 113 released operations — in **both** languages: TypeScript at the package root, and Python in [`python/`](./python/README.md) (PyPI takeover pending). Migration is tracked on the wayfinder map [UXE-152](https://linear.app/composio/issue/UXE-152).
 
 ## Usage
 
@@ -92,6 +92,337 @@ const composio = new Composio({ apiKey, transport })
 Existing `fetch` and `fetchOptions` constructor options remain supported. They cannot be combined
 with `transport` because a request can have only one HTTP dispatcher.
 
+## Effect
+
+`@composio/client/effect` is the same API surface for applications written with
+[Effect](https://effect.website). Every operation returns an `Effect` whose failures are tagged
+errors, the transport is the `HttpClient` in context, and interrupting a call aborts its request.
+
+Use it when the calling code is already Effect code and would otherwise wrap each call in
+`Effect.tryPromise` and inspect what was thrown. Otherwise use the package root: it needs no peer
+dependency, loads faster and spends less time per request (see [Performance](#performance)).
+
+The accessor chains, method names, argument order and request and response types are the root
+client's, and a call sends the same method, URL, body and headers as the root client does for the same
+input. All 113 operations of the spec are there.
+
+### Install
+
+```sh
+pnpm add @composio/client effect
+```
+
+`effect` is an optional peer dependency. The root entry and the `./pagination` and `./resources`
+subpaths never import it and load without it.
+
+- **Supported range: `effect >=4.0.3 <4.1.0`.** The manifest declares the peer as `*`, because a
+  bounded optional peer makes npm refuse the whole install for a project that lists some other
+  `effect` and never imports this subpath. The cost is that a package manager does not warn about an
+  unsupported version. The range above is the one the subpath is tested against.
+- **Install exactly one copy of `effect`.** With two copies, even one patch apart, the project does
+  not type-check: the client's `Effect`, `Layer` and `HttpClient` are not assignable to the
+  application's. At run time `Redacted` values do not cross between copies and `instanceof` is false,
+  and nothing warns about it.
+- **The supported range bounds your Effect upgrades.** The client runs on the application's `effect`,
+  so moving to a new Effect minor waits for a client release whose supported range includes it.
+
+### Construct a client
+
+```ts
+import { Effect, Layer } from 'effect'
+import * as FetchHttpClient from 'effect/http/FetchHttpClient'
+import { ComposioClient, layer, layerConfig, layerFetch } from '@composio/client/effect'
+
+// Explicit options, over a fetch-backed `HttpClient` the layer brings with it.
+const live = layerFetch({ apiKey: 'your-api-key' })
+
+// Explicit options, over the `HttpClient` the application provides.
+const overMyTransport = layer({ apiKey: 'your-api-key' }).pipe(Layer.provide(FetchHttpClient.layer))
+
+// Options read from the `COMPOSIO_*` settings.
+const fromConfig = layerConfig().pipe(Layer.provide(FetchHttpClient.layer))
+
+const program = Effect.gen(function* () {
+  const composio = yield* ComposioClient
+  const toolkit = yield* composio.toolkits.retrieve('github')
+  return toolkit.slug
+})
+
+const slug: Promise<string> = Effect.runPromise(program.pipe(Effect.provide(live)))
+```
+
+`make(options, httpClient)` builds the same client synchronously from an `HttpClient` you already
+hold, and throws where the layers fail.
+
+Only `layerConfig` reads the environment. It reads `COMPOSIO_API_KEY`, `COMPOSIO_USER_API_KEY`,
+`COMPOSIO_ORG_API_KEY`, `COMPOSIO_BASE_URL` and `COMPOSIO_ALLOW_INSECURE_HTTP=1` through Effect's
+`Config`, so the `ConfigProvider` in context decides where they come from; by default that is the
+process environment. An option passed to `layerConfig` wins over its setting, and `null` for a
+credential means none, whatever is configured. `make`, `layer` and `layerFetch` read nothing.
+
+A credential option takes a `string` or a `Redacted<string>`. Construction fails with a
+`ConfigurationError` when a credentialed origin is not HTTPS (loopback and `allowInsecureHTTP`
+excepted, as on the root client), or when `decode: true` is given without `schemas`.
+
+The resources are plain objects of functions, not classes, so a method can be passed around without
+binding. Two things on the root client have no counterpart here: the resources that hold no operation
+(`migration`, `project.config`), and the deprecated `custom.deleteToolkit(slug, options)` overload —
+only the current `(slug, query, options)` signature exists.
+
+### Errors
+
+Every call fails with a `ComposioError`, a union of tagged errors. The tags are namespaced:
+
+| Tag | When |
+| --- | --- |
+| `@composio/client/BadRequestError` | 400 |
+| `@composio/client/AuthenticationError` | 401 |
+| `@composio/client/PermissionDeniedError` | 403 |
+| `@composio/client/NotFoundError` | 404 |
+| `@composio/client/ConflictError` | 409 |
+| `@composio/client/UnprocessableEntityError` | 422 |
+| `@composio/client/RateLimitError` | 429 |
+| `@composio/client/InternalServerError` | 500 and above |
+| `@composio/client/APIError` | any other non-success status |
+| `@composio/client/APIConnectionError` | the transport failed before a response |
+| `@composio/client/APIConnectionTimeoutError` | an attempt outlived its time budget |
+| `@composio/client/DecodeError` | a success body failed validation (only with `decode: true`) |
+| `@composio/client/ConfigurationError` | no request can be made from this client or call |
+
+```ts
+import { Effect } from 'effect'
+import { isAPIError, type ComposioClientShape } from '@composio/client/effect'
+
+const slugOrNull = (composio: ComposioClientShape, slug: string) =>
+  composio.toolkits.retrieve(slug).pipe(
+    Effect.map((toolkit) => toolkit.slug),
+    Effect.catchTag('@composio/client/NotFoundError', () => Effect.succeed(null)),
+    Effect.tapError((error) =>
+      isAPIError(error) ? Effect.logWarning(`${error.status} ${error.requestId}`) : Effect.void,
+    ),
+  )
+```
+
+A status error carries `status`, `requestId`, `details` (the Composio error envelope, when the body
+is one), `body`, `message`, `method` and `url`. `isAPIError` matches any status error and
+`isComposioError` any error of the union; both test the tag, not the class. There is no access to the
+raw response of a successful call.
+
+Retries and timeouts follow the root client's policy: 2 retries and one minute per attempt by default.
+
+### Streams
+
+Fourteen cursor-paginated operations have a `<method>Stream` beside them that yields items across
+pages:
+
+- `authConfigs.listStream`, `connectedAccounts.listStream`, `files.listStream`,
+  `sessionConfigs.listStream`, `toolkits.listStream`, `toolkits.retrieveMultiStream`,
+  `tools.listStream`, `triggerInstances.listActiveStream`, `triggersTypes.listStream`,
+  `webhookSubscriptions.listStream`
+- `toolRouter.session.configHistoryStream`, `toolRouter.session.toolkitsStream`,
+  `toolRouter.session.toolsStream`, `toolRouter.session.files.listStream`
+
+```ts
+import { Stream } from 'effect'
+import type { ComposioClientShape } from '@composio/client/effect'
+
+const firstSlugs = (composio: ComposioClientShape) =>
+  composio.toolkits.listStream({ limit: 100 }).pipe(
+    Stream.map((toolkit) => toolkit.slug),
+    Stream.take(250),
+    Stream.runCollect,
+  )
+```
+
+A page is requested only when the stream is pulled that far, so `Stream.take` above stops after the
+third page. The cursor rules are those of `@composio/client/pagination`, and a traversal that cannot
+continue — a cursor the server repeats, a page with no `items` array — fails with a
+`ConfigurationError`.
+
+No other operation has a stream. That includes the list operations whose page is not the standard
+`items` and `next_cursor` shape: `org.list` (`organizations`), `org.project.list` and
+`org.owner.project.list` (`data`), and `logs.createToolExecution` (`logs`). Page those by passing
+`next_cursor` back yourself.
+
+### Per-call options
+
+The last argument of every operation and raw method:
+
+```ts
+import type { ComposioClientShape } from '@composio/client/effect'
+
+const once = (composio: ComposioClientShape) =>
+  composio.toolkits.retrieve(
+    'github',
+    {},
+    {
+      headers: { 'x-trace-id': 'abc', 'x-team': null }, // `null` removes a default header
+      maxRetries: 0,
+      timeout: 10_000, // milliseconds, per attempt
+    },
+  )
+```
+
+Per-call headers win over the client's `defaultHeaders`. `decode` is the fourth option, described
+next.
+
+### Decoding
+
+By default a response body is returned as parsed and nothing checks it. Decoding is opt-in, per call
+or as a client default, and needs the response schemas, which are a separate entry:
+
+```ts
+import * as HttpClient from 'effect/http/HttpClient'
+import { Effect } from 'effect'
+import { make } from '@composio/client/effect'
+import { schemaLoaders } from '@composio/client/effect/schemas'
+
+const checkedCategories = (httpClient: HttpClient.HttpClient) => {
+  const composio = make({ apiKey: 'your-api-key', schemas: schemaLoaders }, httpClient)
+  return composio.toolkits.retrieveCategories({ decode: true }).pipe(
+    Effect.catchTag('@composio/client/DecodeError', (error) =>
+      Effect.logError(`${error.operation}: ${JSON.stringify(error.issues)}`).pipe(Effect.as(null)),
+    ),
+  )
+}
+```
+
+- **It validates and changes nothing.** A call that passes returns the body exactly as it was parsed;
+  a field the API returns ahead of the spec is not stripped. The response type is the same either way.
+- **`DecodeError`** carries `operation` (`toolkits.retrieveCategories`), `status`, `requestId`,
+  `method`, `url` and `issues`, each a `path` and a `kind` such as `MissingKey` or `InvalidType`. It
+  never carries the body or the value found: a success body is where this API returns secrets.
+- **`decode: true` needs `schemas`.** As a client option without `schemas` it is a compile error, and a
+  `ConfigurationError` at construction for a caller the types did not reach. A per-call
+  `decode: true` on a client built without `schemas` fails with a `ConfigurationError` before
+  anything is sent.
+- **Schemas load lazily.** `schemaLoaders` is a table of `import()` calls, one per operation. A schema
+  module is loaded by the first call that decodes its operation. A single schema can also be imported
+  directly, for example
+  `import { ToolkitRetrieveCategoriesResponse } from '@composio/client/effect/schemas/toolkits/retrieve-categories'`.
+  A decoding call also checks that the table contains its operation before sending the request. The
+  loader itself runs only after a non-204 success; a failed dynamic import can therefore fail a call
+  after the server has already processed it.
+- **An application that never imports `@composio/client/effect/schemas` ships no schema.** The
+  `./effect` entry does not reach the table, so a bundler has no path to it.
+- A 204 has no body to validate. A raw call is validated when its path is a declared operation's.
+
+A schema is generated from the spec snapshot this version was built from, so decoding holds a
+response to that snapshot. A response from before a required field existed fails: replaying stored
+production responses through the schemas, the four `toolRouter.session` operations `create`,
+`retrieve`, `attach` and `patch` failed on a missing `config.instant` for every capture through
+2026-09-11, taken before the spec declared that field, and passed for the 2026-10-08 capture, taken
+after. The record is in [`docs/upstream-asks.md`](./docs/upstream-asks.md).
+
+### Tracing
+
+One option, `tracing`, says what the client's own requests add to a trace:
+
+| Value | Effect |
+| --- | --- |
+| `'off'` (default) | No span is opened for a request and no trace header is sent, so the request carries exactly the headers the root client sends. |
+| `'span'` | Effect's `HttpClient` opens its client span around each request, a child of the span the call runs in. Nothing about it goes on the wire. |
+| `'propagate'` | The span, also sent to the API as `b3` and `traceparent` headers. |
+
+The option only ever reduces tracing, and only for this client's requests. A span asked for here is
+still subject to the application's own `HttpClient.TracerDisabledWhen` and
+`HttpClient.TracerPropagationEnabled`.
+
+With a span on, the span ends on the client's own error, not on Effect's `HttpClientError`. That
+error holds the request and its credential headers, and a tracer keeps what a span ended on. To do
+this the client reassigns `end` on the span object the tracer returns, so a tracer that returns
+frozen spans throws when a request starts. The replacement costs about a microsecond per request on
+top of the span itself.
+
+### Credentials and redaction
+
+A request carries one credential header, chosen per operation as on the root client: `x-api-key`,
+`x-user-api-key` or `x-org-api-key`. The client holds all three as `Redacted` values and adds all
+three header names to Effect's redaction list for its requests, so spans and renderings of a request
+show `<redacted>`; Effect's own list knows only `x-api-key`.
+
+No error the client produces holds the request, the transport's error or a credential value. One
+caveat: `APIConnectionError.description` is the transport's own message text, copied. A transport
+that writes a header value into its error messages would put it there.
+
+The credential is applied before the request reaches the `HttpClient`, so a transform the application
+puts on its `HttpClient` sees it.
+
+### Redirects
+
+The client follows redirects itself and withdraws credentials once a chain changes origin. It does so
+by dispatching with `redirect: 'manual'`, which a fetch-backed `HttpClient` honors. The guarantee
+holds only when nothing between the client and the wire follows redirects. An `HttpClient` wrapped in
+`HttpClient.followRedirects`, or a transport that follows redirects on its own, forwards the
+credential headers across origins and is unsupported for a credentialed client. Headers an
+application places in `FetchHttpClient.RequestInit` are outside the client's credential handling:
+the credential check does not see them, and they are not withdrawn on a cross-origin redirect.
+
+### Deprecation notices
+
+`deprecationNotices: 'warn' | 'off'`, default `'warn'`. A deprecated input, or a response carrying
+`Deprecation`, `Sunset` and `Link` headers, is reported through Effect's logger at the warning level,
+once per operation and notice for each client. The application's logger and minimum log level decide
+what becomes of it; `'off'` reports nothing.
+
+### Raw methods
+
+`get`, `post`, `put`, `patch` and `delete` reach any path through the same kernel: credentials,
+retries, timeouts, redirects and errors behave as for a generated method.
+
+```ts
+import type { ComposioClientShape } from '@composio/client/effect'
+
+const raw = (composio: ComposioClientShape) =>
+  composio.post<{ id: string }>('/api/v3.1/some/path', {
+    query: { dry_run: true },
+    body: { name: 'example' },
+    maxRetries: 0,
+  })
+```
+
+The type argument is an assertion, not a check.
+
+### Performance
+
+Measured against a mocked transport, so these are client overhead and say nothing about network
+latency. The full tables and method are in
+[`docs/benchmarks/client-overhead.md`](./docs/benchmarks/client-overhead.md); the figures below are
+its 2026-10-13 runs on Node 24.17.0 and Bun 1.4.0, `effect` 4.0.3, one Apple M1 Pro.
+
+**The Effect surface is slower per request than the root client.** Typed geometric mean over two
+runs: 154.1% and 153.2% of the root client by default, 173.8% and 171.1% with `tracing: 'span'`. In
+absolute terms that is 10 to 14 microseconds more per request, and 3 to 5 more with the span on. It
+is a measurement, not a win; what it buys is the typed failure channel, interruption and a transport
+taken from context.
+
+**Decoding costs more than the request.** Validating a twenty-item `toolkits.list` page took a call
+from 77.7 / 78.9 µs to 187.3 / 192.4 µs, about 110 µs or 5.5 µs per item.
+
+**Import time**, over what Effect's own HTTP modules already cost, minimum / median of thirty in
+milliseconds:
+
+| | Node, modules | Node, bundle | Bun, modules | Bun, bundle |
+| --- | ---: | ---: | ---: | ---: |
+| `./effect`, never decodes | 5.5 / 5.8 | 3.6 / 3.7 | 2.7 / 3.7 | 10.3 / 11.1 |
+| plus importing `schemaLoaders` | −0.2 / 0.4 | 8.6 / 9.3 | −0.1 / −0.6 | 4.7 / 4.7 |
+
+The published-module lanes are noisy, which is how a difference comes out negative. Effect itself
+is the larger part: 114.8 / 116.4 ms as modules on Node and 21.1 / 22.3 ms bundled, against 9.1 /
+10.0 ms and 3.9 / 4.1 ms for the root client.
+
+**Bundle size** of a single-file consumer: Effect's HTTP modules alone, then with a client that never
+decodes, then with the loader table and every schema it reaches.
+
+| Bundler | Effect alone | never decodes | decodes |
+| --- | ---: | ---: | ---: |
+| rolldown | 498 kB | 732 kB | 893 kB |
+| `bun build` | 266 kB | 705 kB | 1088 kB |
+
+**Package weight.** The schema modules make the package larger on disk: 3.4 MB unpacked in 509 files,
+of which 2.1 MB and 328 files are `dist/effect/schemas*`, against 1.1 MB in 176 files for
+`2.0.0-rc.11` as published. None of it is on the root entry's import path.
+
 ## Upgrade from Stainless 0.1.x to 2.0
 
 By default, the 2.0 client refuses to send credentials over plain HTTP unless the hostname is
@@ -123,21 +454,22 @@ Toolchain is pinned via [mise](https://mise.jdx.dev) (`mise install`): Node 24,
 
 ```sh
 pnpm install
-pnpm generate       # hey-api + compat codegen: spec/openapi.json → src/generated + src/compat/resources (do not edit)
+pnpm generate       # hey-api + compat and Effect codegen: spec/openapi.json → src/generated, src/compat/resources, src/effect/generated (do not edit)
 pnpm lint           # eslint over src, test, codegen, parity, and demo
 pnpm typecheck      # tsgo (TS native), including type tests and demo
 pnpm typecheck:tsc  # same programs under tsc — both compilers must pass
-pnpm codegen:check  # verify committed src/compat/resources matches the generator
+pnpm codegen:check  # verify every committed generated tree matches the generator
 pnpm test           # unit tests (MSW mocks) + codegen tests
 pnpm build          # tsdown → dist/ (runs publint + arethetypeswrong)
 pnpm test:pack      # pack the real tarball, typecheck + import every drop-in subpath
 pnpm benchmark:baseline # capture the dist/ a benchmark run compares against
 pnpm benchmark      # score SDK overhead against that baseline and against Stainless
+pnpm benchmark:import # time what importing each entry costs, on Node and Bun
 pnpm test:contract  # live API tests; requires COMPOSIO_API_KEY (copy .env.example to .env)
 pnpm refresh-spec   # re-fetch spec/openapi.json from the live backend
 ```
 
-`src/generated/` and `src/compat/resources/` are regenerated output — never edit them by hand; CI fails if they drift from `spec/openapi.json`.
+`src/generated/`, `src/compat/resources/` and `src/effect/generated/` are regenerated output — never edit them by hand; CI fails if they drift from `spec/openapi.json`.
 
 ### Python lane
 

package/dist/{api-key-revocation-Dh-KSokR.mjs → api-key-revocation-DJF8KL2o.mjs}

@@ -1,4 +1,4 @@
-import { c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
+import { b as withOperation, n as generatedOperation } from "./generated-operations-BguuMwpw.mjs";
 
 //#region src/compat/resources/api-key-revocation.ts
 const OP_CREATE = generatedOperation("apiKeyRevocation.create");

package/dist/{auth-Drov-jN8.mjs → auth-CHlaMfu-.mjs}

@@ -1,4 +1,4 @@
-import { t as Session } from "./session-DfISYrbs.mjs";
+import { t as Session } from "./session-BISWW6RD.mjs";
 
 //#region src/compat/resources/auth/auth.ts
 /**

package/dist/{auth-configs-yM05-r6r.mjs → auth-configs-sKOQG2Yw.mjs}

@@ -1,4 +1,4 @@
-import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
+import { b as withOperation, d as path, n as generatedOperation } from "./generated-operations-BguuMwpw.mjs";
 
 //#region src/compat/resources/auth-configs.ts
 const OP_CREATE = generatedOperation("authConfigs.create");

package/dist/{clanker-BYmc69WC.mjs → clanker-DyM265dK.mjs}

@@ -1,4 +1,4 @@
-import { c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
+import { b as withOperation, n as generatedOperation } from "./generated-operations-BguuMwpw.mjs";
 
 //#region src/compat/resources/org/clanker.ts
 const OP_CREATE_CLAIM = generatedOperation("org.clanker.createClaim");

package/dist/{cli-Ce8RT7yp.mjs → cli-zrk9Qew1.mjs}

@@ -1,5 +1,5 @@
-import { c as withOperation, m as mergeHeaders, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
-import { t as Realtime } from "./realtime-Dsk1QGAl.mjs";
+import { M as mergeHeaders, b as withOperation, n as generatedOperation } from "./generated-operations-BguuMwpw.mjs";
+import { t as Realtime } from "./realtime-BY6LAuSf.mjs";
 
 //#region src/compat/resources/cli/cli.ts
 const OP_CREATE_CODACT_FAILURE = generatedOperation("cli.createCodactFailure");

package/dist/{connected-accounts-D__sOoNZ.mjs → connected-accounts-a6ezLeaq.mjs}

@@ -1,4 +1,4 @@
-import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
+import { b as withOperation, d as path, n as generatedOperation } from "./generated-operations-BguuMwpw.mjs";
 
 //#region src/compat/resources/connected-accounts.ts
 const OP_CREATE = generatedOperation("connectedAccounts.create");

package/dist/{consumer-DTh50Hih.mjs → consumer-B0qaosDp.mjs}

@@ -1,5 +1,5 @@
-import { c as withOperation, m as mergeHeaders, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
-import { t as Project } from "./project-D-_r3H1_.mjs";
+import { M as mergeHeaders, b as withOperation, n as generatedOperation } from "./generated-operations-BguuMwpw.mjs";
+import { t as Project } from "./project-B8d4M3Ut.mjs";
 
 //#region src/compat/resources/org/consumer/consumer.ts
 const OP_LIST_CONNECTED_TOOLKITS = generatedOperation("org.consumer.listConnectedToolkits");

package/dist/{custom-CdC-6Y_i.mjs → custom-99mj4dPN.mjs}

@@ -1,4 +1,4 @@
-import { c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
+import { b as withOperation, n as generatedOperation } from "./generated-operations-BguuMwpw.mjs";
 
 //#region src/compat/resources/mcp/custom.ts
 const OP_CREATE = generatedOperation("mcp.custom.create");

package/dist/{custom-nlGufiDz.mjs → custom-Ddfc8mtR.mjs}

@@ -1,4 +1,4 @@
-import { a as path, c as withOperation, n as generatedOperation } from "./generated-operations-CWhusMPU.mjs";
+import { b as withOperation, d as path, n as generatedOperation } from "./generated-operations-BguuMwpw.mjs";
 
 //#region src/compat/legacy-options.ts
 /**

package/dist/effect/schemas/api-key-revocation/create.d.mts

@@ -0,0 +1,8 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/api-key-revocation/create.d.ts
+/** The 200 response of `POST /api/v3.1/api_key_revocation`, which `client.apiKeyRevocation.create` answers with. */
+declare const ApiKeyRevocationCreateResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly received: Schema.Boolean;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ApiKeyRevocationCreateResponse };

package/dist/effect/schemas/api-key-revocation/create.mjs

@@ -0,0 +1,8 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/api-key-revocation/create.ts
+/** The 200 response of `POST /api/v3.1/api_key_revocation`, which `client.apiKeyRevocation.create` answers with. */
+const ApiKeyRevocationCreateResponse = Schema.StructWithRest(Schema.Struct({ "received": Schema.Boolean.annotate({ "description": "Always true when the request body is valid. The response intentionally does not reveal whether any submitted key matched a record." }) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ApiKeyRevocationCreateResponse };

package/dist/effect/schemas/auth/session/retrieve-info.d.mts

@@ -0,0 +1,56 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/auth/session/retrieve-info.d.ts
+/** The 200 response of `GET /api/v3.1/auth/session/info`, which `client.auth.session.retrieveInfo` answers with. */
+declare const SessionRetrieveInfoResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly project: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly auto_id: Schema.Number;
+    readonly id: Schema.String;
+    readonly org_id: Schema.String;
+    readonly name: Schema.String;
+    readonly email: Schema.String;
+    readonly nano_id: Schema.String;
+    readonly created_at: Schema.String;
+    readonly updated_at: Schema.String;
+    readonly webhook_url: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly event_webhook_url: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly webhook_secret: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly triggers_enabled: Schema.Boolean;
+    readonly last_subscribed_at: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly deleted: Schema.Boolean;
+    readonly is_new_webhook: Schema.Boolean;
+    readonly webhook_version: Schema.Literals<readonly ["V1", "V2", "V3"]>;
+    readonly org: Schema.StructWithRest<Schema.Struct<{
+      readonly id: Schema.String;
+      readonly name: Schema.String;
+      readonly plan: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.Null]>;
+  readonly api_key: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly auto_id: Schema.Number;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly project_id: Schema.String;
+    readonly org_member_id: Schema.String;
+    readonly created_at: Schema.String;
+    readonly updated_at: Schema.String;
+    readonly deleted_at: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly key: Schema.String;
+    readonly deleted: Schema.Boolean;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.Null]>;
+  readonly org_member: Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly email: Schema.String;
+    readonly name: Schema.String;
+    readonly role: Schema.String;
+    readonly metadata: Schema.StructWithRest<Schema.Struct<{
+      readonly prefers_old_dashboard: Schema.optionalKey<Schema.Boolean>;
+      readonly onboarding_platform: Schema.optionalKey<Schema.Literals<readonly ["consumer", "developer"]>>;
+      readonly seen_flow_consumer: Schema.optionalKey<Schema.Boolean>;
+      readonly seen_flow_developer: Schema.optionalKey<Schema.Boolean>;
+      readonly seen_flow_cli: Schema.optionalKey<Schema.Boolean>;
+      readonly seen_connect_announcement: Schema.optionalKey<Schema.Boolean>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Boolean, Schema.Number]>>]>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { SessionRetrieveInfoResponse };