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

package/dist/effect/schemas/toolkits/retrieve.mjs

@@ -0,0 +1,202 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/toolkits/retrieve.ts
+/** The 200 response of `GET /api/v3.1/toolkits/{slug}`, which `client.toolkits.retrieve` answers with. */
+const ToolkitRetrieveResponse = Schema.StructWithRest(Schema.Struct({
+	"slug": Schema.String.annotate({
+		"description": "URL-friendly unique identifier for the toolkit",
+		"examples": ["github"]
+	}),
+	"name": Schema.String.annotate({
+		"description": "Human-readable name of the toolkit",
+		"examples": ["GitHub"]
+	}),
+	"type": Schema.Literals(["native", "custom"]).annotate({
+		"description": "Toolkit provenance: \"native\" for Composio-managed toolkits, \"custom\" for a project-registered custom (MCP) toolkit",
+		"examples": ["native"]
+	}),
+	"enabled": Schema.Boolean.annotate({
+		"description": "Indicates if this toolkit is currently enabled and available for use",
+		"examples": [true]
+	}),
+	"access": Schema.optionalKey(Schema.Literals(["all", "user"]).annotate({
+		"description": "[EXPERIMENTAL] Custom toolkits only. \"all\": every user in the project can use it. \"user\": only the user it was created for can.",
+		"examples": ["all"]
+	})),
+	"composio_managed_auth_schemes": Schema.optionalKey(Schema.Array(Schema.String).annotate({
+		"description": "List of authentication methods that Composio manages for this toolkit",
+		"examples": [["oauth2"]]
+	})),
+	"composio_managed_auth": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"mode": Schema.String.annotate({
+			"description": "Authentication mode for the Composio-managed auth config",
+			"examples": ["OAUTH2"]
+		}),
+		"scopes": Schema.StructWithRest(Schema.Struct({ "available": Schema.Array(Schema.String).annotate({ "description": "Available OAuth scopes" }) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({
+			"description": "OAuth scopes available in the Composio-managed auth config for this auth mode.",
+			"examples": [{ "available": ["read", "write"] }]
+		}),
+		"user_scopes": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({ "available": Schema.Array(Schema.String).annotate({ "description": "Available OAuth user scopes" }) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({
+			"description": "OAuth user scopes available in the Composio-managed auth config for this auth mode. Only present for Slack toolkits.",
+			"examples": [{ "available": ["search:read", "users:read"] }]
+		}))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "Managed-auth-only metadata, including the supported OAuth scope ceiling." }),
+	"is_local_toolkit": Schema.Boolean.annotate({
+		"description": "DEPRECATED: This field is no longer meaningful and will always return false. It was previously used to indicate if a toolkit is specific to the current project.",
+		"examples": [false]
+	}),
+	"auth_config_details": Schema.optionalKey(Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"mode": Schema.String.annotate({
+			"description": "The type of authentication mode (e.g., oauth2, basic_auth, api_key)",
+			"examples": ["oauth2"]
+		}),
+		"required_scopes": Schema.Array(Schema.String).annotate({
+			"description": "OAuth scopes that are always requested for this authentication method regardless of the tool-specific scopes selected, such as token-refresh (e.g. offline_access) and identity/whoami scopes. Consumers handling authentication themselves should union these with per-tool scopes.",
+			"examples": [["offline_access", "User.Read"]]
+		}),
+		"fields": Schema.StructWithRest(Schema.Struct({
+			"auth_config_creation": Schema.StructWithRest(Schema.Struct({
+				"required": Schema.Array(Schema.StructWithRest(Schema.Struct({
+					"name": Schema.String,
+					"displayName": Schema.String,
+					"default": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+					"type": Schema.String,
+					"description": Schema.String,
+					"required": Schema.Boolean,
+					"is_secret": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether this field holds a secret/credential value. Clients use it to decide whether to mask the input." })),
+					"legacy_template_name": Schema.optionalKey(Schema.String),
+					"user_visible": Schema.Boolean.annotate({ "description": "Whether this field is shown to the end user in the hosted connect flow. Fields with `false` are never required — the field's `default` applies unless the developer supplies a value on the auth config (e.g. as a shared credential)." })
+				}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])),
+				"optional": Schema.Array(Schema.StructWithRest(Schema.Struct({
+					"name": Schema.String,
+					"displayName": Schema.String,
+					"default": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+					"type": Schema.String,
+					"description": Schema.String,
+					"required": Schema.Boolean,
+					"is_secret": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether this field holds a secret/credential value. Clients use it to decide whether to mask the input." })),
+					"legacy_template_name": Schema.optionalKey(Schema.String),
+					"user_visible": Schema.Boolean.annotate({ "description": "Whether this field is shown to the end user in the hosted connect flow. Fields with `false` are never required — the field's `default` applies unless the developer supplies a value on the auth config (e.g. as a shared credential)." })
+				}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]))
+			}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Form fields needed when creating an authentication configuration" }),
+			"connected_account_initiation": Schema.StructWithRest(Schema.Struct({
+				"required": Schema.Array(Schema.StructWithRest(Schema.Struct({
+					"name": Schema.String,
+					"displayName": Schema.String,
+					"default": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+					"type": Schema.String,
+					"description": Schema.String,
+					"required": Schema.Boolean,
+					"is_secret": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether this field holds a secret/credential value. Clients use it to decide whether to mask the input." })),
+					"legacy_template_name": Schema.optionalKey(Schema.String),
+					"user_visible": Schema.Boolean.annotate({ "description": "Whether this field is shown to the end user in the hosted connect flow. Fields with `false` are never required — the field's `default` applies unless the developer supplies a value on the auth config (e.g. as a shared credential)." })
+				}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])),
+				"optional": Schema.Array(Schema.StructWithRest(Schema.Struct({
+					"name": Schema.String,
+					"displayName": Schema.String,
+					"default": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+					"type": Schema.String,
+					"description": Schema.String,
+					"required": Schema.Boolean,
+					"is_secret": Schema.optionalKey(Schema.Boolean.annotate({ "description": "Whether this field holds a secret/credential value. Clients use it to decide whether to mask the input." })),
+					"legacy_template_name": Schema.optionalKey(Schema.String),
+					"user_visible": Schema.Boolean.annotate({ "description": "Whether this field is shown to the end user in the hosted connect flow. Fields with `false` are never required — the field's `default` applies unless the developer supplies a value on the auth config (e.g. as a shared credential)." })
+				}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]))
+			}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Form fields needed when connecting a user account with this authentication method" })
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Field groups required for different authentication stages" }),
+		"proxy": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({ "base_url": Schema.String.annotate({
+			"description": "URL to which authentication requests will be proxied",
+			"examples": ["https://auth.example.com/proxy"]
+		}) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Configuration for proxying authentication requests to external services" })),
+		"name": Schema.String.annotate({
+			"description": "Display name for this authentication method",
+			"examples": ["OAuth 2.0"]
+		}),
+		"auth_hint_url": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({
+			"description": "URL to a page where users can obtain or configure credentials for this authentication method",
+			"examples": ["https://github.com/settings/tokens"]
+		})),
+		"deprecated_auth_provider_details": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+			"authorization_url": Schema.optionalKey(Schema.String),
+			"token_url": Schema.optionalKey(Schema.String)
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Authentication URL fields for OAuth 2.0 and OAuth 1.0. We don't recommend using this field for authentication and might break post Aug 31 2025." }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Detailed configuration for an authentication method" })).annotate({ "description": "Complete authentication configuration details for each supported auth method" })),
+	"auth_guide_url": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({
+		"description": "URL to a guide page with authentication setup instructions for this toolkit",
+		"examples": ["https://composio.dev/auth/github"]
+	})),
+	"base_url": Schema.optionalKey(Schema.String.annotate({
+		"description": "If evaluation of base URL needs some connection info (like shopify), please create the connection and get the base URL from there",
+		"examples": ["https://api.github.com"]
+	})),
+	"meta": Schema.StructWithRest(Schema.Struct({
+		"created_at": Schema.String.annotate({
+			"description": "Creation date and time of the toolkit",
+			"examples": ["2023-01-15T09:30:00.000Z"]
+		}),
+		"updated_at": Schema.String.annotate({
+			"description": "Last modification date and time of the toolkit",
+			"examples": ["2023-05-20T14:45:00.000Z"]
+		}),
+		"description": Schema.String.annotate({
+			"description": "Human-readable description explaining the toolkit's purpose and functionality",
+			"examples": ["Integrate with GitHub repositories, issues, pull requests, and more."]
+		}),
+		"logo": Schema.String.annotate({
+			"description": "Image URL for the toolkit's branding",
+			"examples": ["https://assets.composio.dev/logos/github.png"]
+		}),
+		"app_url": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]).annotate({
+			"description": "Link to the toolkit's main application or service website",
+			"examples": ["https://github.com"]
+		})),
+		"categories": Schema.Array(Schema.StructWithRest(Schema.Struct({
+			"name": Schema.String.annotate({
+				"description": "Human-readable category name",
+				"examples": ["Developer Tools"]
+			}),
+			"slug": Schema.String.annotate({
+				"description": "URL-friendly identifier for the category",
+				"examples": ["developer-tools"]
+			})
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({
+			"description": "List of categories associated with this toolkit",
+			"examples": [[{
+				"name": "Developer Tools",
+				"slug": "developer-tools"
+			}, {
+				"name": "Productivity",
+				"slug": "productivity"
+			}]]
+		}),
+		"triggers_count": Schema.Number.annotate({
+			"description": "Count of available triggers in this toolkit",
+			"examples": [5]
+		}).check(Schema.isFinite().annotate({ "expected": "a finite number" })),
+		"tools_count": Schema.Number.annotate({
+			"description": "Count of available tools in this toolkit",
+			"examples": [12]
+		}).check(Schema.isFinite().annotate({ "expected": "a finite number" })),
+		"version": Schema.String.annotate({
+			"description": "Version of the toolkit",
+			"examples": ["20250905_00"]
+		}),
+		"available_versions": Schema.Array(Schema.String).annotate({
+			"description": "Available versions of the toolkit",
+			"examples": [["20250905_00", "20250906_00"]]
+		})
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Comprehensive metadata for the toolkit including dates, descriptions, and statistics" }),
+	"get_current_user_endpoint": Schema.optionalKey(Schema.String.annotate({ "description": "Endpoint to get the current user" })),
+	"get_current_user_endpoint_method": Schema.optionalKey(Schema.String.annotate({
+		"description": "HTTP method to use when calling the get current user endpoint (e.g., GET, POST)",
+		"examples": ["GET"]
+	})),
+	"deprecated": Schema.StructWithRest(Schema.Struct({
+		"toolkitId": Schema.String,
+		"getCurrentUserEndpoint": Schema.optionalKey(Schema.String),
+		"rawProxyInfoByAuthSchemes": Schema.Array(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" }))]).annotate({ "description": "Detailed information about a single toolkit" });
+
+//#endregion
+export { ToolkitRetrieveResponse };

package/dist/effect/schemas/tools/execute.d.mts

@@ -0,0 +1,12 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tools/execute.d.ts
+/** The 200 response of `POST /api/v3.1/tools/execute/{tool_slug}`, which `client.tools.execute` answers with. */
+declare const ToolExecuteResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly data: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly error: Schema.Union<readonly [Schema.String, Schema.Null]>;
+  readonly successful: Schema.Boolean;
+  readonly session_info: Schema.optionalKey<Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>, Schema.Null]>>;
+  readonly log_id: Schema.optionalKey<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ToolExecuteResponse };

package/dist/effect/schemas/tools/execute.mjs

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tools/execute.ts
+/** The 200 response of `POST /api/v3.1/tools/execute/{tool_slug}`, which `client.tools.execute` answers with. */
+const ToolExecuteResponse = Schema.StructWithRest(Schema.Struct({
+	"data": Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({
+		"description": "Tool execution output data that varies based on the specific tool",
+		"examples": [{
+			"run_id": 12345678,
+			"status": "queued",
+			"created_at": "2023-01-01T12:00:00Z",
+			"html_url": "https://github.com/octocat/Hello-World/actions/runs/12345678"
+		}]
+	}),
+	"error": Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Error message if the tool execution was not successful (null if successful)" }),
+	"successful": Schema.Boolean.annotate({
+		"description": "Indicates if the tool execution was successful",
+		"examples": [true]
+	}),
+	"session_info": Schema.optionalKey(Schema.Union([Schema.Json.annotate({
+		"expected": "JSON value",
+		"description": "Optional session information for tools that return session context",
+		"examples": [{
+			"session_id": "session-12345",
+			"expires_at": "2023-01-01T13:00:00Z"
+		}]
+	}), Schema.Null])),
+	"log_id": Schema.optionalKey(Schema.String.annotate({
+		"description": "Unique identifier for the execution log (useful for debugging and support)",
+		"examples": ["log_1a2b3c4d5e6f"]
+	}))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolExecuteResponse };

package/dist/effect/schemas/tools/get-input.d.mts

@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tools/get-input.d.ts
+/** The 200 response of `POST /api/v3.1/tools/execute/{tool_slug}/input`, which `client.tools.getInput` answers with. */
+declare const ToolGetInputResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly arguments: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+  readonly error: Schema.optionalKey<Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ToolGetInputResponse };

package/dist/effect/schemas/tools/get-input.mjs

@@ -0,0 +1,22 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tools/get-input.ts
+/** The 200 response of `POST /api/v3.1/tools/execute/{tool_slug}/input`, which `client.tools.getInput` answers with. */
+const ToolGetInputResponse = Schema.StructWithRest(Schema.Struct({
+	"arguments": Schema.optionalKey(Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({
+		"description": "Key-value pairs of arguments required by the tool to accomplish the described task",
+		"examples": [{
+			"repository": "octocat/Hello-World",
+			"workflow_id": "main.yml",
+			"ref": "main",
+			"inputs": { "environment": "production" }
+		}]
+	})),
+	"error": Schema.optionalKey(Schema.String.annotate({
+		"description": "Error message if the arguments could not be generated (null if successful)",
+		"examples": ["Unable to determine the repository name from the provided description"]
+	}))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolGetInputResponse };

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

@@ -0,0 +1,56 @@
+//#region src/effect/generated/schemas/tools/list.d.ts
+/** The 200 response of `GET /api/v3.1/tools`, which `client.tools.list` answers with. */
+declare const ToolListResponse: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+  readonly items: import("effect/Schema").$Array<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+    readonly slug: import("effect/Schema").String;
+    readonly name: import("effect/Schema").String;
+    readonly description: import("effect/Schema").String;
+    readonly toolkit: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+      readonly slug: import("effect/Schema").String;
+      readonly name: import("effect/Schema").String;
+      readonly logo: import("effect/Schema").String;
+    }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+    readonly input_parameters: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+    readonly no_auth: import("effect/Schema").Boolean;
+    readonly available_versions: import("effect/Schema").$Array<import("effect/Schema").String>;
+    readonly version: import("effect/Schema").String;
+    readonly instant: import("effect/Schema").optionalKey<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+      readonly supported: import("effect/Schema").Literal<true>;
+      readonly price: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly description: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+        readonly discount: import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Null]>>;
+      }>>;
+    }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>>;
+    readonly output_parameters: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+    readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
+    readonly scope_requirements: import("effect/Schema").Union<readonly [import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+      readonly all_of: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly any_of: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+          readonly all_of: import("effect/Schema").$Array<import("effect/Schema").String>;
+          readonly source: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+        }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>]>>;
+        readonly when: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").String>>>;
+        readonly source: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+      }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>]>>;
+      readonly source: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+    }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>, import("effect/Schema").Null]>;
+    readonly tags: import("effect/Schema").$Array<import("effect/Schema").String>;
+    readonly human_description: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+    readonly is_deprecated: import("effect/Schema").Boolean;
+    readonly deprecated: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+      readonly displayName: import("effect/Schema").String;
+      readonly version: import("effect/Schema").String;
+      readonly available_versions: import("effect/Schema").$Array<import("effect/Schema").String>;
+      readonly is_deprecated: import("effect/Schema").Boolean;
+      readonly toolkit: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly logo: import("effect/Schema").String;
+      }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+    }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+  }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>>;
+  readonly next_cursor: import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Null]>>;
+  readonly total_pages: import("effect/Schema").Number;
+  readonly current_page: import("effect/Schema").Number;
+  readonly total_items: import("effect/Schema").Number;
+}>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+//#endregion
+export { ToolListResponse };

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

@@ -0,0 +1,8 @@
+import { ToolsPaginated } from "../components/tools-paginated.mjs";
+
+//#region src/effect/generated/schemas/tools/list.ts
+/** The 200 response of `GET /api/v3.1/tools`, which `client.tools.list` answers with. */
+const ToolListResponse = ToolsPaginated;
+
+//#endregion
+export { ToolListResponse };

package/dist/effect/schemas/tools/proxy.d.mts

@@ -0,0 +1,16 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tools/proxy.d.ts
+/** The 200 response of `POST /api/v3.1/tools/execute/proxy`, which `client.tools.proxy` answers with. */
+declare const ToolProxyResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly data: Schema.optionalKey<Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>, Schema.Null]>>;
+  readonly binary_data: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+    readonly url: Schema.String;
+    readonly content_type: Schema.String;
+    readonly size: Schema.Number;
+    readonly expires_at: Schema.optionalKey<Schema.String>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly status: Schema.Number;
+  readonly headers: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ToolProxyResponse };

package/dist/effect/schemas/tools/proxy.mjs

@@ -0,0 +1,36 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tools/proxy.ts
+/** The 200 response of `POST /api/v3.1/tools/execute/proxy`, which `client.tools.proxy` answers with. */
+const ToolProxyResponse = Schema.StructWithRest(Schema.Struct({
+	"data": Schema.optionalKey(Schema.Union([Schema.Json.annotate({
+		"expected": "JSON value",
+		"description": "The response data returned from the proxied API",
+		"examples": [{
+			"id": "123",
+			"name": "Resource Name",
+			"created_at": "2023-01-01T00:00:00Z"
+		}]
+	}), Schema.Null])),
+	"binary_data": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({
+		"url": Schema.String.annotate({ "description": "URL to download binary content" }),
+		"content_type": Schema.String.annotate({ "description": "Content-Type of the binary data" }),
+		"size": Schema.Number.annotate({ "description": "File size in bytes" }).check(Schema.isFinite().annotate({ "expected": "a finite number" })),
+		"expires_at": Schema.optionalKey(Schema.String.annotate({ "description": "ISO 8601 timestamp when the URL expires" }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Binary body response data. Present when the response is a binary file." })),
+	"status": Schema.Number.annotate({
+		"description": "The HTTP status code returned from the proxied API",
+		"examples": [200]
+	}).check(Schema.isFinite().annotate({ "expected": "a finite number" })),
+	"headers": Schema.optionalKey(Schema.Record(Schema.String, Schema.String).annotate({
+		"description": "The HTTP headers returned from the proxied API",
+		"examples": [{
+			"content-type": "application/json",
+			"cache-control": "no-cache",
+			"host": "api.example.com"
+		}]
+	}))
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolProxyResponse };

package/dist/effect/schemas/tools/retrieve-enum.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tools/retrieve-enum.d.ts
+/** The 200 response of `GET /api/v3.1/tools/enum`, which `client.tools.retrieveEnum` answers with. */
+declare const ToolRetrieveEnumResponse: Schema.$Array<Schema.String>;
+//#endregion
+export { ToolRetrieveEnumResponse };

package/dist/effect/schemas/tools/retrieve-enum.mjs

@@ -0,0 +1,8 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tools/retrieve-enum.ts
+/** The 200 response of `GET /api/v3.1/tools/enum`, which `client.tools.retrieveEnum` answers with. */
+const ToolRetrieveEnumResponse = Schema.Array(Schema.String).annotate({ "description": "JSON string containing all tool enum values from latest version of each toolkit" });
+
+//#endregion
+export { ToolRetrieveEnumResponse };

package/dist/effect/schemas/tools/retrieve-required-scopes.d.mts

@@ -0,0 +1,22 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/tools/retrieve-required-scopes.d.ts
+/** The 200 response of `POST /api/v3.1/tools/scopes/required`, which `client.tools.retrieveRequiredScopes` answers with. */
+declare const ToolRetrieveRequiredScopesResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly scopes_required: Schema.$Array<Schema.String>;
+  readonly per_tool_requirements: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly tool: Schema.String;
+    readonly scope_requirements: Schema.Union<readonly [Schema.StructWithRest<Schema.Struct<{
+      readonly all_of: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.StructWithRest<Schema.Struct<{
+        readonly any_of: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.StructWithRest<Schema.Struct<{
+          readonly all_of: Schema.$Array<Schema.String>;
+          readonly source: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>>;
+        readonly when: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Array<Schema.String>>>;
+        readonly source: Schema.optionalKey<Schema.$Array<Schema.String>>;
+      }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>]>>;
+      readonly source: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>, Schema.Null]>;
+  }>, 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 { ToolRetrieveRequiredScopesResponse };

package/dist/effect/schemas/tools/retrieve-required-scopes.mjs

@@ -0,0 +1,33 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/tools/retrieve-required-scopes.ts
+/** The 200 response of `POST /api/v3.1/tools/scopes/required`, which `client.tools.retrieveRequiredScopes` answers with. */
+const ToolRetrieveRequiredScopesResponse = Schema.StructWithRest(Schema.Struct({
+	"scopes_required": Schema.Array(Schema.String).annotate({
+		"description": "A combined list of all unique scopes required by the specified tools",
+		"examples": [[
+			"channels:read",
+			"chat:write",
+			"https://www.googleapis.com/auth/gmail.modify",
+			"repo",
+			"user:email"
+		]]
+	}),
+	"per_tool_requirements": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"tool": Schema.String,
+		"scope_requirements": Schema.Union([Schema.StructWithRest(Schema.Struct({
+			"all_of": Schema.Array(Schema.Union([Schema.String, Schema.StructWithRest(Schema.Struct({
+				"any_of": Schema.Array(Schema.Union([Schema.String, Schema.StructWithRest(Schema.Struct({
+					"all_of": Schema.Array(Schema.String).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })),
+					"source": Schema.optionalKey(Schema.Array(Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })))
+				}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])])).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })),
+				"when": Schema.optionalKey(Schema.Record(Schema.String, Schema.Array(Schema.String).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })))),
+				"source": Schema.optionalKey(Schema.Array(Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })))
+			}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])])),
+			"source": Schema.optionalKey(Schema.Array(Schema.String.check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" }))).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })))
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]), Schema.Null])
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "Per-tool structured scope requirements. Null scope_requirements marks unmigrated legacy tools." })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolRetrieveRequiredScopesResponse };

package/dist/effect/schemas/tools/retrieve.d.mts

@@ -0,0 +1,50 @@
+//#region src/effect/generated/schemas/tools/retrieve.d.ts
+/** The 200 response of `GET /api/v3.1/tools/{tool_slug}`, which `client.tools.retrieve` answers with. */
+declare const ToolRetrieveResponse: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+  readonly slug: import("effect/Schema").String;
+  readonly name: import("effect/Schema").String;
+  readonly description: import("effect/Schema").String;
+  readonly toolkit: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+    readonly slug: import("effect/Schema").String;
+    readonly name: import("effect/Schema").String;
+    readonly logo: import("effect/Schema").String;
+  }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+  readonly input_parameters: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+  readonly no_auth: import("effect/Schema").Boolean;
+  readonly available_versions: import("effect/Schema").$Array<import("effect/Schema").String>;
+  readonly version: import("effect/Schema").String;
+  readonly instant: import("effect/Schema").optionalKey<import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+    readonly supported: import("effect/Schema").Literal<true>;
+    readonly price: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+      readonly description: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+      readonly discount: import("effect/Schema").optionalKey<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Null]>>;
+    }>>;
+  }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>>;
+  readonly output_parameters: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>;
+  readonly scopes: import("effect/Schema").$Array<import("effect/Schema").String>;
+  readonly scope_requirements: import("effect/Schema").Union<readonly [import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+    readonly all_of: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+      readonly any_of: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+        readonly all_of: import("effect/Schema").$Array<import("effect/Schema").String>;
+        readonly source: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+      }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>]>>;
+      readonly when: import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").$Array<import("effect/Schema").String>>>;
+      readonly source: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+    }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>]>>;
+    readonly source: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+  }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>, import("effect/Schema").Null]>;
+  readonly tags: import("effect/Schema").$Array<import("effect/Schema").String>;
+  readonly human_description: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+  readonly is_deprecated: import("effect/Schema").Boolean;
+  readonly deprecated: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+    readonly displayName: import("effect/Schema").String;
+    readonly version: import("effect/Schema").String;
+    readonly available_versions: import("effect/Schema").$Array<import("effect/Schema").String>;
+    readonly is_deprecated: import("effect/Schema").Boolean;
+    readonly toolkit: import("effect/Schema").StructWithRest<import("effect/Schema").Struct<{
+      readonly logo: import("effect/Schema").String;
+    }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+  }>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+}>, readonly [import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>]>;
+//#endregion
+export { ToolRetrieveResponse };

package/dist/effect/schemas/tools/retrieve.mjs

@@ -0,0 +1,8 @@
+import { ToolDetails } from "../components/tool-details.mjs";
+
+//#region src/effect/generated/schemas/tools/retrieve.ts
+/** The 200 response of `GET /api/v3.1/tools/{tool_slug}`, which `client.tools.retrieve` answers with. */
+const ToolRetrieveResponse = ToolDetails;
+
+//#endregion
+export { ToolRetrieveResponse };

package/dist/effect/schemas/trigger-instances/list-active.d.mts

@@ -0,0 +1,34 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/trigger-instances/list-active.d.ts
+/** The 200 response of `GET /api/v3.1/trigger_instances/active`, which `client.triggerInstances.listActive` answers with. */
+declare const TriggerInstanceListActiveResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly items: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly uuid: Schema.optionalKey<Schema.String>;
+    readonly id: Schema.String;
+    readonly connected_account_id: Schema.String;
+    readonly trigger_name: Schema.String;
+    readonly connected_account_uuid: Schema.String;
+    readonly user_id: Schema.String;
+    readonly trigger_data: Schema.optionalKey<Schema.String>;
+    readonly version: Schema.String;
+    readonly trigger_config: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly egress_url: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly state: Schema.Union<readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.Null]>;
+    readonly updated_at: Schema.String;
+    readonly disabled_at: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly disabledAt: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly connectedAccountId: Schema.String;
+    readonly triggerName: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly triggerConfig: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly deprecated: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly createdAt: 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>>]>>;
+  readonly next_cursor: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+  readonly total_pages: Schema.Number;
+  readonly current_page: Schema.Number;
+  readonly total_items: Schema.Number;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { TriggerInstanceListActiveResponse };