@composio/client 2.0.0-rc.9 → 2.0.0

package/dist/effect/schemas/toolkits/recommend-scopes.d.mts

@@ -0,0 +1,19 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/toolkits/recommend-scopes.d.ts
+/** The 200 response of `POST /api/v3.1/toolkits/{toolkit_slug}/scopes/recommended`, which `client.toolkits.recommendScopes` answers with. */
+declare const ToolkitRecommendScopesResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly auth_scheme: Schema.String;
+  readonly toolkit_version: Schema.String;
+  readonly grant_context: Schema.$Record<Schema.String, Schema.String>;
+  readonly scopes: Schema.StructWithRest<Schema.Struct<{
+    readonly least_privilege: Schema.$Array<Schema.String>;
+    readonly fewest: Schema.$Array<Schema.String>;
+    readonly conditional: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+      readonly scope: Schema.String;
+      readonly when: Schema.$Record<Schema.String, Schema.$Array<Schema.String>>;
+      readonly for: Schema.$Array<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 [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ToolkitRecommendScopesResponse };

package/dist/effect/schemas/toolkits/recommend-scopes.mjs

@@ -0,0 +1,21 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/toolkits/recommend-scopes.ts
+/** The 200 response of `POST /api/v3.1/toolkits/{toolkit_slug}/scopes/recommended`, which `client.toolkits.recommendScopes` answers with. */
+const ToolkitRecommendScopesResponse = Schema.StructWithRest(Schema.Struct({
+	"auth_scheme": Schema.String.annotate({ "description": "Auth scheme the recommendation was computed under." }),
+	"toolkit_version": Schema.String.annotate({ "description": "Concrete toolkit version the answer was computed from; pass it back as toolkit_version to pin." }),
+	"grant_context": Schema.Record(Schema.String, Schema.String).annotate({ "description": "The effective grant_context the recommendation was computed with - the toolkit default overlaid with your overrides; {} when none applies." }),
+	"scopes": Schema.StructWithRest(Schema.Struct({
+		"least_privilege": Schema.Array(Schema.String).annotate({ "description": "Narrowest documented option per requirement." }),
+		"fewest": Schema.Array(Schema.String).annotate({ "description": "Smallest scope set covering all requirements." }),
+		"conditional": Schema.Array(Schema.StructWithRest(Schema.Struct({
+			"scope": Schema.String.annotate({ "description": "The scope needed only under the `when` guard." }),
+			"when": Schema.Record(Schema.String, Schema.Array(Schema.String)).annotate({ "description": "Condition for when this scope is needed: input field name to qualifying values (any value matches within a field; all fields must match)." }),
+			"for": Schema.Array(Schema.String).annotate({ "description": "Tool slugs that need this scope under the guard." })
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "Scopes needed only for particular call-time inputs; the lists above already include them worst-case, so a caller that knows its inputs may subtract the rest. Empty when none apply." })
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolkitRecommendScopesResponse };

package/dist/effect/schemas/toolkits/retrieve-categories.d.mts

@@ -0,0 +1,15 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/toolkits/retrieve-categories.d.ts
+/** The 200 response of `GET /api/v3.1/toolkits/categories`, which `client.toolkits.retrieveCategories` answers with. */
+declare const ToolkitRetrieveCategoriesResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly items: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly name: Schema.String;
+    readonly id: Schema.String;
+  }>, 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.Finite;
+  readonly current_page: Schema.Finite;
+  readonly total_items: Schema.Finite;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ToolkitRetrieveCategoriesResponse };

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

@@ -0,0 +1,23 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/toolkits/retrieve-categories.ts
+/** The 200 response of `GET /api/v3.1/toolkits/categories`, which `client.toolkits.retrieveCategories` answers with. */
+const ToolkitRetrieveCategoriesResponse = Schema.StructWithRest(Schema.Struct({
+	"items": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"name": Schema.String.annotate({
+			"description": "Display name of the toolkit category",
+			"examples": ["Developer Tools"]
+		}),
+		"id": Schema.String.annotate({
+			"description": "URL-friendly unique identifier for the category, used for filtering toolkits",
+			"examples": ["developer-tools"]
+		})
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Information about a single toolkit category" })),
+	"next_cursor": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	"total_pages": Schema.Finite,
+	"current_page": Schema.Finite,
+	"total_items": Schema.Finite
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolkitRetrieveCategoriesResponse };

package/dist/effect/schemas/toolkits/retrieve-changelog.d.mts

@@ -0,0 +1,16 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/toolkits/retrieve-changelog.d.ts
+/** The 200 response of `GET /api/v3.1/toolkits/changelog`, which `client.toolkits.retrieveChangelog` answers with. */
+declare const ToolkitRetrieveChangelogResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly items: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly name: Schema.String;
+    readonly display_name: Schema.String;
+    readonly versions: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+      readonly version: Schema.String;
+      readonly changelog: 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 [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ToolkitRetrieveChangelogResponse };

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

@@ -0,0 +1,16 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/toolkits/retrieve-changelog.ts
+/** The 200 response of `GET /api/v3.1/toolkits/changelog`, which `client.toolkits.retrieveChangelog` answers with. */
+const ToolkitRetrieveChangelogResponse = Schema.StructWithRest(Schema.Struct({ "items": Schema.Array(Schema.StructWithRest(Schema.Struct({
+	"slug": Schema.String.annotate({ "description": "Toolkit slug" }),
+	"name": Schema.String.annotate({ "description": "Toolkit name" }),
+	"display_name": Schema.String.annotate({ "description": "Toolkit display name" }),
+	"versions": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"version": Schema.String.annotate({ "description": "Version identifier" }),
+		"changelog": Schema.String.annotate({ "description": "Changelog for this version" })
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "Array of version changelogs" })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "List of toolkits with their changelogs" }) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolkitRetrieveChangelogResponse };

package/dist/effect/schemas/toolkits/retrieve-multi.d.mts

@@ -0,0 +1,42 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/toolkits/retrieve-multi.d.ts
+/** The 200 response of `POST /api/v3.1/toolkits/multi`, which `client.toolkits.retrieveMulti` answers with. */
+declare const ToolkitRetrieveMultiResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly items: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly name: Schema.String;
+    readonly type: Schema.Literals<readonly ["native", "custom"]>;
+    readonly instant: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly supported: Schema.Literal<true>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly access: Schema.optionalKey<Schema.Literals<readonly ["all", "user"]>>;
+    readonly auth_schemes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly composio_managed_auth_schemes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly is_local_toolkit: Schema.Boolean;
+    readonly no_auth: Schema.optionalKey<Schema.Boolean>;
+    readonly auth_guide_url: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly deprecated: Schema.StructWithRest<Schema.Struct<{
+      readonly toolkitId: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly meta: Schema.StructWithRest<Schema.Struct<{
+      readonly created_at: Schema.String;
+      readonly updated_at: Schema.String;
+      readonly description: Schema.String;
+      readonly logo: Schema.String;
+      readonly app_url: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+      readonly categories: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+      }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+      readonly triggers_count: Schema.Number;
+      readonly tools_count: Schema.Number;
+      readonly version: 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.Finite;
+  readonly current_page: Schema.Finite;
+  readonly total_items: Schema.Finite;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ToolkitRetrieveMultiResponse };

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

@@ -0,0 +1,15 @@
+import { ToolkitListResponseItems } from "../components/toolkit-list-response-items.mjs";
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/toolkits/retrieve-multi.ts
+/** The 200 response of `POST /api/v3.1/toolkits/multi`, which `client.toolkits.retrieveMulti` answers with. */
+const ToolkitRetrieveMultiResponse = Schema.StructWithRest(Schema.Struct({
+	"items": ToolkitListResponseItems,
+	"next_cursor": Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	"total_pages": Schema.Finite,
+	"current_page": Schema.Finite,
+	"total_items": Schema.Finite
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolkitRetrieveMultiResponse };

package/dist/effect/schemas/toolkits/retrieve-scopes-grant-context.d.mts

@@ -0,0 +1,15 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/toolkits/retrieve-scopes-grant-context.d.ts
+/** The 200 response of `GET /api/v3.1/toolkits/{toolkit_slug}/scopes/grant_context`, which `client.toolkits.retrieveScopesGrantContext` answers with. */
+declare const ToolkitRetrieveScopesGrantContextResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly auth_scheme: Schema.String;
+  readonly toolkit_version: Schema.String;
+  readonly grant_context_dimensions: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly dimension: Schema.String;
+    readonly description: Schema.String;
+    readonly values: Schema.$Array<Schema.String>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+  readonly default_grant_context: Schema.$Record<Schema.String, Schema.String>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ToolkitRetrieveScopesGrantContextResponse };

package/dist/effect/schemas/toolkits/retrieve-scopes-grant-context.mjs

@@ -0,0 +1,17 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/toolkits/retrieve-scopes-grant-context.ts
+/** The 200 response of `GET /api/v3.1/toolkits/{toolkit_slug}/scopes/grant_context`, which `client.toolkits.retrieveScopesGrantContext` answers with. */
+const ToolkitRetrieveScopesGrantContextResponse = Schema.StructWithRest(Schema.Struct({
+	"auth_scheme": Schema.String.annotate({ "description": "Auth scheme whose scope catalog the vocabulary was read from." }),
+	"toolkit_version": Schema.String.annotate({ "description": "Concrete toolkit version the answer was computed from; pass it back as toolkit_version to pin." }),
+	"grant_context_dimensions": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"dimension": Schema.String.annotate({ "description": "Context in which you could grant scopes to your user." }),
+		"description": Schema.String.annotate({ "description": "What this dimension means and when to pass it." }),
+		"values": Schema.Array(Schema.String).annotate({ "description": "Values that this dimension can take." })
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])).annotate({ "description": "Dimensions this toolkit accepts in grant_context under the auth scheme; [] when no scope depends on grant_context." }),
+	"default_grant_context": Schema.Record(Schema.String, Schema.String).annotate({ "description": "The grant_context assumed when you pass none — pass a dimension and its selected value only to override or extend it." })
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ToolkitRetrieveScopesGrantContextResponse };

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

@@ -0,0 +1,110 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/toolkits/retrieve.d.ts
+/** The 200 response of `GET /api/v3.1/toolkits/{slug}`, which `client.toolkits.retrieve` answers with. */
+declare const ToolkitRetrieveResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly slug: Schema.String;
+  readonly name: Schema.String;
+  readonly type: Schema.Literals<readonly ["native", "custom"]>;
+  readonly enabled: Schema.Boolean;
+  readonly access: Schema.optionalKey<Schema.Literals<readonly ["all", "user"]>>;
+  readonly composio_managed_auth_schemes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+  readonly composio_managed_auth: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly mode: Schema.String;
+    readonly scopes: Schema.StructWithRest<Schema.Struct<{
+      readonly available: Schema.$Array<Schema.String>;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly user_scopes: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly available: Schema.$Array<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 is_local_toolkit: Schema.Boolean;
+  readonly auth_config_details: Schema.optionalKey<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly mode: Schema.String;
+    readonly required_scopes: Schema.$Array<Schema.String>;
+    readonly fields: Schema.StructWithRest<Schema.Struct<{
+      readonly auth_config_creation: Schema.StructWithRest<Schema.Struct<{
+        readonly required: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+          readonly name: Schema.String;
+          readonly displayName: Schema.String;
+          readonly default: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+          readonly type: Schema.String;
+          readonly description: Schema.String;
+          readonly required: Schema.Boolean;
+          readonly is_secret: Schema.optionalKey<Schema.Boolean>;
+          readonly legacy_template_name: Schema.optionalKey<Schema.String>;
+          readonly user_visible: Schema.Boolean;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+        readonly optional: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+          readonly name: Schema.String;
+          readonly displayName: Schema.String;
+          readonly default: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+          readonly type: Schema.String;
+          readonly description: Schema.String;
+          readonly required: Schema.Boolean;
+          readonly is_secret: Schema.optionalKey<Schema.Boolean>;
+          readonly legacy_template_name: Schema.optionalKey<Schema.String>;
+          readonly user_visible: Schema.Boolean;
+        }>, 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 connected_account_initiation: Schema.StructWithRest<Schema.Struct<{
+        readonly required: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+          readonly name: Schema.String;
+          readonly displayName: Schema.String;
+          readonly default: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+          readonly type: Schema.String;
+          readonly description: Schema.String;
+          readonly required: Schema.Boolean;
+          readonly is_secret: Schema.optionalKey<Schema.Boolean>;
+          readonly legacy_template_name: Schema.optionalKey<Schema.String>;
+          readonly user_visible: Schema.Boolean;
+        }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+        readonly optional: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+          readonly name: Schema.String;
+          readonly displayName: Schema.String;
+          readonly default: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+          readonly type: Schema.String;
+          readonly description: Schema.String;
+          readonly required: Schema.Boolean;
+          readonly is_secret: Schema.optionalKey<Schema.Boolean>;
+          readonly legacy_template_name: Schema.optionalKey<Schema.String>;
+          readonly user_visible: Schema.Boolean;
+        }>, 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>>]>;
+    readonly proxy: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly base_url: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly name: Schema.String;
+    readonly auth_hint_url: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly deprecated_auth_provider_details: Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
+      readonly authorization_url: Schema.optionalKey<Schema.String>;
+      readonly token_url: 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>>]>>>;
+  readonly auth_guide_url: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+  readonly base_url: Schema.optionalKey<Schema.String>;
+  readonly meta: Schema.StructWithRest<Schema.Struct<{
+    readonly created_at: Schema.String;
+    readonly updated_at: Schema.String;
+    readonly description: Schema.String;
+    readonly logo: Schema.String;
+    readonly app_url: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Null]>>;
+    readonly categories: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+      readonly name: Schema.String;
+      readonly slug: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>;
+    readonly triggers_count: Schema.Number;
+    readonly tools_count: Schema.Number;
+    readonly version: Schema.String;
+    readonly available_versions: Schema.$Array<Schema.String>;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly get_current_user_endpoint: Schema.optionalKey<Schema.String>;
+  readonly get_current_user_endpoint_method: Schema.optionalKey<Schema.String>;
+  readonly deprecated: Schema.StructWithRest<Schema.Struct<{
+    readonly toolkitId: Schema.String;
+    readonly getCurrentUserEndpoint: Schema.optionalKey<Schema.String>;
+    readonly rawProxyInfoByAuthSchemes: Schema.$Array<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 { ToolkitRetrieveResponse };

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 };