@composio/client 2.0.0-rc.9 → 2.0.0

package/dist/_internal-C4YQE9nG.d.mts

@@ -0,0 +1,281 @@
+import { A as PermissionsResolveParams, C as TriggerListResponse, F as CliCreateCodactFailureResponse, Ga as HeadersLike, H as RealtimeAuthParams, I as CliCreateSessionParams, L as CliCreateSessionResponse, P as CliCreateCodactFailureParams, R as CliGetSessionParams, S as TriggerListParams, Sa as AuthOf, U as RealtimeAuthResponse, W as RealtimeCredentialsResponse, _ as ToolListParams, c as ConsumerRetrieveConfigResponse, d as ProjectResolveParams, f as ProjectResolveResponse, g as ToolListFieldsResponse, j as PermissionsResolveResponse, ka as APIErrorBody, o as ConsumerListConnectedToolkitsParams, s as ConsumerListConnectedToolkitsResponse, v as ToolListResponse, w as TriggerRetrieveResponse, y as ToolRetrieveResponse, z as CliGetSessionResponse } from "./_internal-BBZ8gsxI.mjs";
+import { Effect, Redacted } from "effect";
+import "effect/http/HttpClient";
+import * as Schema from "effect/Schema";
+//#region src/effect/errors.d.ts
+/** The fields every error for a non-success HTTP response carries. */
+interface APIErrorFields {
+  /** The message the compat client builds for the same response. */
+  readonly message: string;
+  /** The request method, upper-cased. */
+  readonly method: string;
+  /** The origin plus the operation template, or `/<custom>` for an undeclared path. */
+  readonly url: string;
+  /** HTTP status of the response. */
+  readonly status: number;
+  /**
+   * The request id the API assigned: the `x-request-id` response header first,
+   * the envelope's `request_id` otherwise.
+   */
+  readonly requestId: string | undefined;
+  /** The body narrowed to the Composio error envelope, when it is one. */
+  readonly details: APIErrorBody['error'] | undefined;
+  /** The parsed JSON body, whatever its shape; `undefined` when it is not JSON. */
+  readonly body: unknown;
+}
+declare const BadRequestError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/BadRequestError";
+} & Readonly<A>;
+declare class BadRequestError extends BadRequestError_base<APIErrorFields> {}
+declare const AuthenticationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/AuthenticationError";
+} & Readonly<A>;
+declare class AuthenticationError extends AuthenticationError_base<APIErrorFields> {}
+declare const PermissionDeniedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/PermissionDeniedError";
+} & Readonly<A>;
+declare class PermissionDeniedError extends PermissionDeniedError_base<APIErrorFields> {}
+declare const NotFoundError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/NotFoundError";
+} & Readonly<A>;
+declare class NotFoundError extends NotFoundError_base<APIErrorFields> {}
+declare const ConflictError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/ConflictError";
+} & Readonly<A>;
+declare class ConflictError extends ConflictError_base<APIErrorFields> {}
+declare const UnprocessableEntityError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/UnprocessableEntityError";
+} & Readonly<A>;
+declare class UnprocessableEntityError extends UnprocessableEntityError_base<APIErrorFields> {}
+declare const RateLimitError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/RateLimitError";
+} & Readonly<A>;
+declare class RateLimitError extends RateLimitError_base<APIErrorFields> {}
+declare const InternalServerError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/InternalServerError";
+} & Readonly<A>;
+/** Any status of 500 and above. */
+declare class InternalServerError extends InternalServerError_base<APIErrorFields> {}
+declare const APIError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/APIError";
+} & Readonly<A>;
+/** A non-success status none of the other classes names. */
+declare class APIError extends APIError_base<APIErrorFields> {}
+declare const APIConnectionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/APIConnectionError";
+} & Readonly<A>;
+/**
+ * The request never produced a response: the transport failed below HTTP.
+ *
+ * The transport's error is reduced to `reason` (which of its failure kinds it
+ * was) and `description` (its own text, or its cause's messages).
+ */
+declare class APIConnectionError extends APIConnectionError_base<{
+  readonly message: string;
+  readonly method: string;
+  readonly url: string;
+  readonly reason: string;
+  readonly description: string | undefined;
+}> {}
+declare const APIConnectionTimeoutError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/APIConnectionTimeoutError";
+} & Readonly<A>;
+/** An attempt outlived its time budget. */
+declare class APIConnectionTimeoutError extends APIConnectionTimeoutError_base<{
+  readonly message: string;
+  readonly method: string;
+  readonly url: string;
+}> {}
+/** One thing wrong with a response body: where, and what kind of problem. */
+interface DecodeIssue {
+  readonly path: ReadonlyArray<string | number>;
+  readonly kind: string;
+}
+declare const DecodeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/DecodeError";
+} & Readonly<A>;
+/** A success response whose body is not what it claims to be. */
+declare class DecodeError extends DecodeError_base<{
+  readonly message: string;
+  readonly method: string;
+  readonly url: string;
+  readonly status: number;
+  readonly requestId: string | undefined;
+  /** The operation's public chain (`toolkits.list`), or `undefined` for an undeclared path. */
+  readonly operation: string | undefined;
+  readonly issues: ReadonlyArray<DecodeIssue>;
+}> {}
+declare const ConfigurationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "@composio/client/ConfigurationError";
+} & Readonly<A>;
+/**
+ * The client or the call is set up in a way no request can be made from: a
+ * credentialed origin that cannot carry a credential, a path parameter that
+ * would rewrite the path, a body that does not serialize. Retrying cannot
+ * change the answer.
+ */
+declare class ConfigurationError extends ConfigurationError_base<{
+  readonly message: string;
+}> {}
+/** An error for a non-success HTTP response, of whichever status class. */
+type APIStatusError = BadRequestError | AuthenticationError | PermissionDeniedError | NotFoundError | ConflictError | UnprocessableEntityError | RateLimitError | InternalServerError | APIError;
+/** Every failure an operation of the Effect surface can end with. */
+type ComposioError = APIStatusError | APIConnectionError | APIConnectionTimeoutError | DecodeError | ConfigurationError;
+/**
+ * Whether a value is an error for a non-success HTTP response, of any status
+ * class. Structural, so it holds across duplicated copies of this module.
+ */
+declare const isAPIError: (value: unknown) => value is APIStatusError;
+/** Whether a value is any error this surface produces. Structural, like {@link isAPIError}. */
+declare const isComposioError: (value: unknown) => value is ComposioError;
+//#endregion
+//#region src/effect/credentials.d.ts
+type Key = string | Redacted.Redacted<string>;
+type Provider = () => Key | PromiseLike<Key>;
+/** A string or `Redacted` key, or a function returning one, called once per call. */
+type Credential = Key | Provider;
+type Auth = AuthOf<Credential>;
+//#endregion
+//#region src/effect/decode.d.ts
+/**
+ * What a client decodes with: an operation's public chain (`toolkits.list`) →
+ * a function that loads its response schema. `schemaLoaders`, the export of
+ * `@composio/client/effect/schemas`, is the table for every operation.
+ */
+type SchemaLoaders = Readonly<Record<string, () => Promise<Schema.Codec<unknown>>>>;
+//#endregion
+//#region src/effect/request.d.ts
+/**
+ * What the client's own requests add to a trace:
+ *
+ * - `'off'` — nothing. No span is opened for a request and no trace header is
+ *   sent, so the client sends exactly the headers the Promise 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`.
+ *
+ * Only this client's requests are affected, and only ever toward less: a
+ * span asked for here is still subject to the application's own
+ * `HttpClient.TracerDisabledWhen` and `HttpClient.TracerPropagationEnabled`.
+ */
+type Tracing = 'off' | 'span' | 'propagate';
+/** Per-call options: the last argument of every operation and raw method. */
+interface RequestOptions {
+  /** Headers for this call; they win over the client's defaults, and `null` removes one. */
+  readonly headers?: HeadersLike;
+  /**
+   * Maximum retries for temporary failures on this call. Without it, a call
+   * whose method is idempotent (`GET`, `HEAD`, `OPTIONS`, `PUT`, `DELETE`)
+   * takes the client's, which defaults to 2, and any other call is sent once.
+   */
+  readonly maxRetries?: number | undefined;
+  /**
+   * Time budget for each attempt of this call, in milliseconds; a redirect
+   * chain shares one. Defaults to the client's, which defaults to one minute.
+   */
+  readonly timeout?: number | undefined;
+  /**
+   * Validates the success body against the operation's response schema, and
+   * fails with a `DecodeError` naming where it does not match. The value
+   * returned is the body as parsed either way: validation removes nothing.
+   * Defaults to the client's, which defaults to `false`.
+   *
+   * The schema is loaded on first use, through the `schemas` the client was
+   * constructed with; asking a client that was given none fails the call with
+   * a `ConfigurationError`. A raw call is validated when its path is a
+   * declared operation's, and has no schema to be held to otherwise.
+   */
+  readonly decode?: boolean | undefined;
+}
+/** What a raw `get` accepts beside the per-call options. */
+interface RawRequestOptions extends RequestOptions {
+  readonly query?: Record<string, unknown> | null | undefined;
+}
+/** What a raw `post`, `put`, `patch` or `delete` accepts beside the per-call options. */
+interface RawBodyRequestOptions extends RawRequestOptions {
+  readonly body?: unknown;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/cli/realtime.d.ts
+/** `client._internal.cli.realtime` on the Effect surface. */
+interface Realtime {
+  readonly auth: (body: RealtimeAuthParams, options?: RequestOptions) => Effect.Effect<RealtimeAuthResponse, ComposioError>;
+  readonly credentials: (options?: RequestOptions) => Effect.Effect<RealtimeCredentialsResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/cli/cli.d.ts
+/** `client._internal.cli` on the Effect surface. */
+interface Cli {
+  readonly realtime: Realtime;
+  readonly createCodactFailure: (params: CliCreateCodactFailureParams, options?: RequestOptions) => Effect.Effect<CliCreateCodactFailureResponse, ComposioError>;
+  readonly createSession: (body?: CliCreateSessionParams | null | undefined, options?: RequestOptions) => Effect.Effect<CliCreateSessionResponse, ComposioError>;
+  readonly getSession: (query: CliGetSessionParams, options?: RequestOptions) => Effect.Effect<CliGetSessionResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/consumer/permissions.d.ts
+/** `client._internal.consumer.permissions` on the Effect surface. */
+interface Permissions {
+  readonly resolve: (body?: PermissionsResolveParams | null | undefined, options?: RequestOptions) => Effect.Effect<PermissionsResolveResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/consumer/consumer.d.ts
+/** `client._internal.consumer` on the Effect surface. */
+interface Consumer$1 {
+  readonly permissions: Permissions;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/logs/triggers.d.ts
+/** `client._internal.logs.triggers` on the Effect surface. */
+interface Triggers {
+  /** @deprecated Deprecated in the input OpenAPI schema. */
+  readonly retrieve: (id: string, options?: RequestOptions) => Effect.Effect<TriggerRetrieveResponse, ComposioError>;
+  readonly list: (body?: TriggerListParams | null | undefined, options?: RequestOptions) => Effect.Effect<TriggerListResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/logs/tools.d.ts
+/** `client._internal.logs.tools` on the Effect surface. */
+interface Tools {
+  readonly retrieve: (id: string, options?: RequestOptions) => Effect.Effect<ToolRetrieveResponse, ComposioError>;
+  /** @deprecated Deprecated in the input OpenAPI schema. */
+  readonly list: (body: ToolListParams, options?: RequestOptions) => Effect.Effect<ToolListResponse, ComposioError>;
+  /** @deprecated Deprecated in the input OpenAPI schema. */
+  readonly listFields: (options?: RequestOptions) => Effect.Effect<ToolListFieldsResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/logs/logs.d.ts
+/** `client._internal.logs` on the Effect surface. */
+interface Logs {
+  readonly triggers: Triggers;
+  readonly tools: Tools;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/org/consumer/project.d.ts
+/** `client._internal.org.consumer.project` on the Effect surface. */
+interface Project {
+  readonly resolve: (params: ProjectResolveParams, options?: RequestOptions) => Effect.Effect<ProjectResolveResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/org/consumer/consumer.d.ts
+/** `client._internal.org.consumer` on the Effect surface. */
+interface Consumer {
+  readonly project: Project;
+  readonly listConnectedToolkits: (params: ConsumerListConnectedToolkitsParams, options?: RequestOptions) => Effect.Effect<ConsumerListConnectedToolkitsResponse, ComposioError>;
+  readonly retrieveConfig: (options?: RequestOptions) => Effect.Effect<ConsumerRetrieveConfigResponse, ComposioError>;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/org/org.d.ts
+/** `client._internal.org` on the Effect surface. */
+interface Org {
+  readonly consumer: Consumer;
+}
+//#endregion
+//#region src/effect/generated/resources/_internal/_internal.d.ts
+/** `client._internal` on the Effect surface. */
+interface Internal {
+  readonly cli: Cli;
+  readonly consumer: Consumer$1;
+  readonly logs: Logs;
+  readonly org: Org;
+}
+//#endregion
+export { PermissionDeniedError as C, isComposioError as D, isAPIError as E, NotFoundError as S, UnprocessableEntityError as T, ConfigurationError as _, Tracing as a, DecodeIssue as b, Credential as c, APIError as d, APIErrorFields as f, ComposioError as g, BadRequestError as h, RequestOptions as i, APIConnectionError as l, AuthenticationError as m, RawBodyRequestOptions as n, SchemaLoaders as o, APIStatusError as p, RawRequestOptions as r, Auth as s, Internal as t, APIConnectionTimeoutError as u, ConflictError as v, RateLimitError as w, InternalServerError as x, DecodeError as y };

package/dist/effect/internal.d.mts

@@ -0,0 +1,9 @@
+import { t as Internal } from "../_internal-C4YQE9nG.mjs";
+//#region src/effect/internal.d.ts
+declare module '@composio/client/effect' {
+  interface ComposioClientShape {
+    readonly _internal: Internal;
+  }
+}
+//#endregion
+export type { Internal };

package/dist/effect/internal.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/effect/schemas/_internal/cli/create-codact-failure.d.mts

@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/_internal/cli/create-codact-failure.d.ts
+/** The 200 response of `POST /api/v3.1/cli/codact_failures`, which `client._internal.cli.createCodactFailure` answers with. */
+declare const CliCreateCodactFailureResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly tracked: Schema.Boolean;
+  readonly id: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { CliCreateCodactFailureResponse };

package/dist/effect/schemas/_internal/cli/create-codact-failure.mjs

@@ -0,0 +1,17 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/_internal/cli/create-codact-failure.ts
+/** The 200 response of `POST /api/v3.1/cli/codact_failures`, which `client._internal.cli.createCodactFailure` answers with. */
+const CliCreateCodactFailureResponse = Schema.StructWithRest(Schema.Struct({
+	"tracked": Schema.Boolean.annotate({
+		"description": "Whether the codact failure row was accepted for storage.",
+		"examples": [true]
+	}),
+	"id": Schema.String.annotate({
+		"description": "Unique identifier for the stored failure row.",
+		"examples": ["5f6f7a1d-72d1-4f7c-bf3a-2fd7421bc123"]
+	})
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { CliCreateCodactFailureResponse };

package/dist/effect/schemas/_internal/cli/create-session.d.mts

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/_internal/cli/create-session.d.ts
+/** The 201 response of `POST /api/v3.1/cli/create-session`, which `client._internal.cli.createSession` answers with. */
+declare const CliCreateSessionResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly id: Schema.String;
+  readonly code: Schema.String;
+  readonly expiresAt: Schema.String;
+  readonly status: Schema.Literals<readonly ["pending", "linked"]>;
+  readonly scope: Schema.Literals<readonly ["project", "user"]>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { CliCreateSessionResponse };

package/dist/effect/schemas/_internal/cli/create-session.mjs

@@ -0,0 +1,26 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/_internal/cli/create-session.ts
+/** The 201 response of `POST /api/v3.1/cli/create-session`, which `client._internal.cli.createSession` answers with. */
+const CliCreateSessionResponse = Schema.StructWithRest(Schema.Struct({
+	"id": Schema.String.annotate({ "description": "Unique identifier for the CLI session. UUID v4 format used for tracking and retrieval." }),
+	"code": Schema.String.annotate({
+		"description": "The 6-character hexadecimal code used for CLI login",
+		"examples": ["ABC123"]
+	}),
+	"expiresAt": Schema.String.annotate({
+		"description": "The ISO timestamp when the session expires",
+		"examples": ["2023-01-01T12:00:00.000Z"]
+	}),
+	"status": Schema.Literals(["pending", "linked"]).annotate({
+		"description": "The current status of the session",
+		"examples": ["pending"]
+	}),
+	"scope": Schema.Literals(["project", "user"]).annotate({
+		"description": "The key scope for this session",
+		"examples": ["project"]
+	})
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { CliCreateSessionResponse };

package/dist/effect/schemas/_internal/cli/get-session.d.mts

@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/_internal/cli/get-session.d.ts
+/** The 200 response of `GET /api/v3.1/cli/get-session`, which `client._internal.cli.getSession` answers with. */
+declare const CliGetSessionResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly id: Schema.String;
+  readonly code: Schema.String;
+  readonly status: Schema.Literals<readonly ["pending", "linked"]>;
+  readonly expiresAt: Schema.String;
+  readonly account: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly email: Schema.String;
+    readonly name: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.Null]>;
+  readonly api_key: Schema.Union<readonly [Schema.String, Schema.Null]>;
+  readonly scope: Schema.Union<readonly [Schema.Literals<readonly ["project", "user"]>, Schema.Null]>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { CliGetSessionResponse };

package/dist/effect/schemas/_internal/cli/get-session.mjs

@@ -0,0 +1,48 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/_internal/cli/get-session.ts
+/** The 200 response of `GET /api/v3.1/cli/get-session`, which `client._internal.cli.getSession` answers with. */
+const CliGetSessionResponse = Schema.StructWithRest(Schema.Struct({
+	"id": Schema.String.annotate({
+		"description": "The CLI session ID, or the code for a lookup by code",
+		"examples": ["123e4567-e89b-12d3-a456-426614174000"]
+	}),
+	"code": Schema.String.annotate({
+		"description": "The 6-character hexadecimal code used for CLI login",
+		"examples": ["ABC123"]
+	}),
+	"status": Schema.Literals(["pending", "linked"]).annotate({
+		"description": "The current status of the session",
+		"examples": ["pending"]
+	}),
+	"expiresAt": Schema.String.annotate({
+		"description": "The ISO timestamp when the session expires",
+		"examples": ["2023-01-01T12:00:00.000Z"]
+	}),
+	"account": Schema.Union([Schema.StructWithRest(Schema.Struct({
+		"id": Schema.String.annotate({
+			"description": "The ID of the linked account",
+			"examples": ["user_12345"]
+		}),
+		"email": Schema.String.annotate({
+			"description": "The email address of the linked account",
+			"examples": ["user@example.com"],
+			"format": "email"
+		}),
+		"name": Schema.String.annotate({
+			"description": "The display name of the linked account",
+			"examples": ["John Doe"]
+		})
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]), Schema.Null]).annotate({ "description": "Information about the linked account, if any. Null if the session status is \"pending\"." }),
+	"api_key": Schema.Union([Schema.String, Schema.Null]).annotate({
+		"description": "The API key for the linked account",
+		"examples": ["1234567890"]
+	}),
+	"scope": Schema.Union([Schema.Literals(["project", "user"]), Schema.Null]).annotate({
+		"description": "The key scope for this session",
+		"examples": ["project"]
+	})
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { CliGetSessionResponse };

package/dist/effect/schemas/_internal/cli/realtime/auth.d.mts

@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/_internal/cli/realtime/auth.d.ts
+/** The 200 response of `POST /api/v3.1/cli/realtime/auth`, which `client._internal.cli.realtime.auth` answers with. */
+declare const RealtimeAuthResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly auth: Schema.String;
+  readonly channel_data: Schema.optionalKey<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { RealtimeAuthResponse };

package/dist/effect/schemas/_internal/cli/realtime/auth.mjs

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/_internal/cli/realtime/auth.ts
+/** The 200 response of `POST /api/v3.1/cli/realtime/auth`, which `client._internal.cli.realtime.auth` answers with. */
+const RealtimeAuthResponse = Schema.StructWithRest(Schema.Struct({
+	"auth": Schema.String.annotate({ "description": "The authentication string for Pusher" }),
+	"channel_data": Schema.optionalKey(Schema.String.annotate({ "description": "Channel data for presence channels" }))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { RealtimeAuthResponse };

package/dist/effect/schemas/_internal/cli/realtime/credentials.d.mts

@@ -0,0 +1,10 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/_internal/cli/realtime/credentials.d.ts
+/** The 200 response of `GET /api/v3.1/cli/realtime/credentials`, which `client._internal.cli.realtime.credentials` answers with. */
+declare const RealtimeCredentialsResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly pusher_key: Schema.String;
+  readonly pusher_cluster: Schema.String;
+  readonly project_id: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { RealtimeCredentialsResponse };

package/dist/effect/schemas/_internal/cli/realtime/credentials.mjs

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/_internal/cli/realtime/credentials.ts
+/** The 200 response of `GET /api/v3.1/cli/realtime/credentials`, which `client._internal.cli.realtime.credentials` answers with. */
+const RealtimeCredentialsResponse = Schema.StructWithRest(Schema.Struct({
+	"pusher_key": Schema.String.annotate({ "description": "The Pusher client key for subscribing to the trigger" }),
+	"pusher_cluster": Schema.String.annotate({ "description": "The Pusher cluster for subscribing to the trigger" }),
+	"project_id": Schema.String.annotate({ "description": "The project nanoId associated with the API Key provided. Used as part of the CLI channel name: private-cli-{project_id}" })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { RealtimeCredentialsResponse };

package/dist/effect/schemas/_internal/consumer/permissions/resolve.d.mts

@@ -0,0 +1,13 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/_internal/consumer/permissions/resolve.d.ts
+/** The 200 response of `POST /api/v3.1/consumer/permissions/resolve`, which `client._internal.consumer.permissions.resolve` answers with. */
+declare const PermissionsResolveResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly experimental: Schema.StructWithRest<Schema.Struct<{
+    readonly permissions: Schema.StructWithRest<Schema.Struct<{
+      readonly default: Schema.Literals<readonly ["allow_all", "ask_every_call", "ask_once_per_session"]>;
+      readonly overrides: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Literals<readonly ["always_allow", "always_deny", "ask_once", "ask_always"]>>>;
+    }>, 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>>]>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { PermissionsResolveResponse };

package/dist/effect/schemas/_internal/consumer/permissions/resolve.mjs

@@ -0,0 +1,20 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/_internal/consumer/permissions/resolve.ts
+/** The 200 response of `POST /api/v3.1/consumer/permissions/resolve`, which `client._internal.consumer.permissions.resolve` answers with. */
+const PermissionsResolveResponse = Schema.StructWithRest(Schema.Struct({ "experimental": Schema.StructWithRest(Schema.Struct({ "permissions": Schema.StructWithRest(Schema.Struct({
+	"default": Schema.Literals([
+		"allow_all",
+		"ask_every_call",
+		"ask_once_per_session"
+	]).annotate({ "description": "Default elicitation behavior when no override matches. `allow_all` runs every tool without prompting; `ask_every_call` prompts on each invocation; `ask_once_per_session` prompts once and remembers the answer for the rest of the session." }),
+	"overrides": Schema.optionalKey(Schema.Record(Schema.String, Schema.Literals([
+		"always_allow",
+		"always_deny",
+		"ask_once",
+		"ask_always"
+	])).annotate({ "description": "Per-tool overrides keyed by `${toolSlug}:${connectedAccountId ?? \"__none__\"}`, plus account-wide overrides keyed by `*:${connectedAccountId ?? \"__none__\"}`. Exact tool overrides take precedence over account-wide overrides. `always_allow` skips the prompt and runs the tool; `always_deny` blocks the tool; `ask_once` prompts once per session (allow/deny) and remembers; `ask_always` prompts on every call with allow-once/allow-session/deny, ignoring any cached session allow. Overrides take precedence over `default`." }))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { PermissionsResolveResponse };

package/dist/effect/schemas/_internal/logs/tools/list-fields.d.mts

@@ -0,0 +1,13 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/_internal/logs/tools/list-fields.d.ts
+/** The 200 response of `GET /api/v3.1/internal/action_execution/fields`, which `client._internal.logs.tools.listFields` answers with. */
+declare const ToolListFieldsResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly fields: Schema.$Record<Schema.String, Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly displayName: Schema.String;
+    readonly type: Schema.String;
+    readonly regex: Schema.optionalKey<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>>]>;
+//#endregion
+export { ToolListFieldsResponse };

package/dist/effect/schemas/_internal/logs/tools/list-fields.mjs

@@ -0,0 +1,13 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/_internal/logs/tools/list-fields.ts
+/** The 200 response of `GET /api/v3.1/internal/action_execution/fields`, which `client._internal.logs.tools.listFields` answers with. */
+const ToolListFieldsResponse = Schema.StructWithRest(Schema.Struct({ "fields": Schema.Record(Schema.String, Schema.Array(Schema.StructWithRest(Schema.Struct({
+	"id": Schema.String.annotate({ "description": "The id of the field" }),
+	"displayName": Schema.String.annotate({ "description": "The display name of the field" }),
+	"type": Schema.String.annotate({ "description": "The type of the field" }),
+	"regex": Schema.optionalKey(Schema.String.annotate({ "description": "The regex of the field" }))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]))) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolListFieldsResponse };

package/dist/effect/schemas/_internal/logs/tools/list.d.mts

@@ -0,0 +1,28 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/_internal/logs/tools/list.d.ts
+/** The 200 response of `POST /api/v3.1/internal/action_execution/logs`, which `client._internal.logs.tools.list` answers with. */
+declare const ToolListResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly data: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly actionKey: Schema.String;
+    readonly appKey: Schema.String;
+    readonly app: Schema.StructWithRest<Schema.Struct<{
+      readonly icon: Schema.String;
+      readonly name: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly connectedAccountId: Schema.String;
+    readonly entityId: Schema.String;
+    readonly status: Schema.Literals<readonly ["success", "failed"]>;
+    readonly executionTime: Schema.Finite;
+    readonly minimalResponse: Schema.String;
+    readonly metadata: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly recipe_id: Schema.optionalKey<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly credentialSource: Schema.optionalKey<Schema.Literals<readonly ["connected_account", "instant_account", "custom_auth", "no_auth"]>>;
+    readonly instantCharge: Schema.optionalKey<Schema.String>;
+    readonly createdAt: Schema.Finite;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly nextCursor: Schema.Union<readonly [Schema.Finite, Schema.Null]>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ToolListResponse };

package/dist/effect/schemas/_internal/logs/tools/list.mjs

@@ -0,0 +1,33 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/_internal/logs/tools/list.ts
+/** The 200 response of `POST /api/v3.1/internal/action_execution/logs`, which `client._internal.logs.tools.list` answers with. */
+const ToolListResponse = Schema.StructWithRest(Schema.Struct({
+	"data": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"id": Schema.String,
+		"actionKey": Schema.String,
+		"appKey": Schema.String,
+		"app": Schema.StructWithRest(Schema.Struct({
+			"icon": Schema.String,
+			"name": Schema.String
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]),
+		"connectedAccountId": Schema.String,
+		"entityId": Schema.String,
+		"status": Schema.Literals(["success", "failed"]),
+		"executionTime": Schema.Finite,
+		"minimalResponse": Schema.String,
+		"metadata": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({ "recipe_id": Schema.optionalKey(Schema.String) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])),
+		"credentialSource": Schema.optionalKey(Schema.Literals([
+			"connected_account",
+			"instant_account",
+			"custom_auth",
+			"no_auth"
+		])),
+		"instantCharge": Schema.optionalKey(Schema.String.annotate({ "description": "Instant charge in USD for this tool, as an exact decimal string." })),
+		"createdAt": Schema.Finite
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])),
+	"nextCursor": Schema.Union([Schema.Finite, Schema.Null])
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolListResponse };