@composio/client 2.0.0-rc.9 → 2.0.0

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").Finite;
+  readonly current_page: import("effect/Schema").Finite;
+  readonly total_items: import("effect/Schema").Finite;
+}>, 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,37 @@
+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 type: Schema.Literals<readonly ["webhook", "poll"]>;
+    readonly fallback_reason: Schema.Union<readonly [Schema.String, Schema.Null]>;
+    readonly polling_interval: Schema.Union<readonly [Schema.Int, Schema.Null]>;
+    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.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 { TriggerInstanceListActiveResponse };

package/dist/effect/schemas/trigger-instances/list-active.mjs

@@ -0,0 +1,49 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/trigger-instances/list-active.ts
+/** The 200 response of `GET /api/v3.1/trigger_instances/active`, which `client.triggerInstances.listActive` answers with. */
+const TriggerInstanceListActiveResponse = Schema.StructWithRest(Schema.Struct({
+	"items": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"uuid": Schema.optionalKey(Schema.String.annotate({ "description": "Unique identifier of the trigger instance" })),
+		"id": Schema.String.annotate({
+			"description": "Nano ID of the trigger instance",
+			"format": "triggerInstanceId"
+		}),
+		"connected_account_id": Schema.String.annotate({ "description": "ID of the connected account this trigger is associated with" }),
+		"trigger_name": Schema.String.annotate({ "description": "Name of the trigger" }),
+		"connected_account_uuid": Schema.String.annotate({ "description": "UUID of the connected account this trigger is associated with" }),
+		"user_id": Schema.String.annotate({ "description": "ID of the user this trigger is associated with" }),
+		"trigger_data": Schema.optionalKey(Schema.String.annotate({ "description": "Additional data associated with the trigger instance" })),
+		"version": Schema.String.annotate({ "description": "Version of the trigger instance" }),
+		"trigger_config": Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "Configuration for the trigger" }),
+		"type": Schema.Literals(["webhook", "poll"]).annotate({
+			"description": "How this trigger instance gets events: webhook (the provider notifies) or poll (a scheduled check).",
+			"examples": ["webhook"]
+		}),
+		"fallback_reason": Schema.Union([Schema.String, Schema.Null]).annotate({
+			"description": "Set when Composio downgraded to a poll-based mechanism instead of webhooks for this trigger.",
+			"examples": ["No webhook endpoint found for toolkit \"gmail\". Create a webhook endpoint before setting up triggers."]
+		}),
+		"polling_interval": Schema.Union([Schema.Int, Schema.Null]).annotate({
+			"description": "Minutes between scheduled polls for a poll instance.",
+			"examples": [15]
+		}),
+		"egress_url": Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "Delivery URL override for this trigger instance: its events are sent here instead of the project webhook URL, while signing, the payload version and enabled events still come from the project webhook subscription. Null means no override." }),
+		"state": Schema.Union([Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })), Schema.Null]).annotate({ "description": "DEPRECATED: This field exposes internal state and will be removed in a future version." }),
+		"updated_at": Schema.String.annotate({ "description": "ISO 8601 timestamp when the trigger instance was updated" }),
+		"disabled_at": Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "ISO 8601 timestamp when the trigger instance was disabled, if applicable" }),
+		"disabledAt": Schema.Union([Schema.String, Schema.Null]).annotate({ "description": "DEPRECATED: This parameter will be removed in a future version. Please use disabled_at instead." }),
+		"connectedAccountId": Schema.String.annotate({ "description": "DEPRECATED: This parameter will be removed in a future version. Please use connected_account_id instead." }),
+		"triggerName": Schema.String.annotate({ "description": "DEPRECATED: This parameter will be removed in a future version. Please use trigger_name instead." }),
+		"updatedAt": Schema.String.annotate({ "description": "DEPRECATED: This parameter will be removed in a future version. Please use updated_at instead." }),
+		"triggerConfig": Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({ "description": "DEPRECATED: This parameter will be removed in a future version. Please use trigger_config instead." }),
+		"deprecated": Schema.optionalKey(Schema.StructWithRest(Schema.Struct({ "createdAt": Schema.String.annotate({ "description": "Deprecated created_at for the trigger instance" }) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Deprecated fields for the trigger instance" }))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])),
+	"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 { TriggerInstanceListActiveResponse };

package/dist/effect/schemas/trigger-instances/manage/delete.d.mts

@@ -0,0 +1,8 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/trigger-instances/manage/delete.d.ts
+/** The 200 response of `DELETE /api/v3.1/trigger_instances/manage/{triggerId}`, which `client.triggerInstances.manage.delete` answers with. */
+declare const ManageDeleteResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly trigger_id: Schema.String;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ManageDeleteResponse };

package/dist/effect/schemas/trigger-instances/manage/delete.mjs

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/trigger-instances/manage/delete.ts
+/** The 200 response of `DELETE /api/v3.1/trigger_instances/manage/{triggerId}`, which `client.triggerInstances.manage.delete` answers with. */
+const ManageDeleteResponse = Schema.StructWithRest(Schema.Struct({ "trigger_id": Schema.String.annotate({
+	"description": "The ID of the deleted trigger instance",
+	"format": "triggerInstanceId"
+}) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ManageDeleteResponse };

package/dist/effect/schemas/trigger-instances/manage/update.d.mts

@@ -0,0 +1,8 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/trigger-instances/manage/update.d.ts
+/** The 200 response of `PATCH /api/v3.1/trigger_instances/manage/{triggerId}`, which `client.triggerInstances.manage.update` answers with. */
+declare const ManageUpdateResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly status: Schema.Literal<"success">;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { ManageUpdateResponse };

package/dist/effect/schemas/trigger-instances/manage/update.mjs

@@ -0,0 +1,8 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/trigger-instances/manage/update.ts
+/** The 200 response of `PATCH /api/v3.1/trigger_instances/manage/{triggerId}`, which `client.triggerInstances.manage.update` answers with. */
+const ManageUpdateResponse = Schema.StructWithRest(Schema.Struct({ "status": Schema.Literal("success").annotate({ "description": "Status of the operation" }) }), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { ManageUpdateResponse };

package/dist/effect/schemas/trigger-instances/upsert.d.mts

@@ -0,0 +1,11 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/trigger-instances/upsert.d.ts
+/** The 200 response of `POST /api/v3.1/trigger_instances/{slug}/upsert`, which `client.triggerInstances.upsert` answers with. */
+declare const TriggerInstanceUpsertResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly trigger_id: Schema.String;
+  readonly type: Schema.Literals<readonly ["webhook", "poll"]>;
+  readonly fallback_reason: Schema.Union<readonly [Schema.String, Schema.Null]>;
+  readonly polling_interval: Schema.Union<readonly [Schema.Int, Schema.Null]>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { TriggerInstanceUpsertResponse };

package/dist/effect/schemas/trigger-instances/upsert.mjs

@@ -0,0 +1,22 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/trigger-instances/upsert.ts
+/** The 200 response of `POST /api/v3.1/trigger_instances/{slug}/upsert`, which `client.triggerInstances.upsert` answers with. */
+const TriggerInstanceUpsertResponse = Schema.StructWithRest(Schema.Struct({
+	"trigger_id": Schema.String.annotate({ "description": "ID of the updated trigger" }),
+	"type": Schema.Literals(["webhook", "poll"]).annotate({
+		"description": "How this trigger instance gets events: webhook (the provider notifies) or poll (a scheduled check).",
+		"examples": ["webhook"]
+	}),
+	"fallback_reason": Schema.Union([Schema.String, Schema.Null]).annotate({
+		"description": "Set when Composio downgraded to a poll-based mechanism instead of webhooks for this trigger.",
+		"examples": ["No webhook endpoint found for toolkit \"gmail\". Create a webhook endpoint before setting up triggers."]
+	}),
+	"polling_interval": Schema.Union([Schema.Int, Schema.Null]).annotate({
+		"description": "Minutes between scheduled polls for a poll instance.",
+		"examples": [15]
+	})
+}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]);
+
+//#endregion
+export { TriggerInstanceUpsertResponse };

package/dist/effect/schemas/triggers-types/list.d.mts

@@ -0,0 +1,28 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/triggers-types/list.d.ts
+/** The 200 response of `GET /api/v3.1/triggers_types`, which `client.triggersTypes.list` answers with. */
+declare const TriggersTypeListResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly items: Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly instructions: Schema.String;
+    readonly type: Schema.Literals<readonly ["webhook", "poll"]>;
+    readonly types: Schema.$Array<Schema.Literals<readonly ["webhook", "poll"]>>;
+    readonly toolkit: Schema.StructWithRest<Schema.Struct<{
+      readonly slug: Schema.String;
+      readonly name: Schema.String;
+      readonly logo: Schema.String;
+    }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly config: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly version: Schema.String;
+    readonly requires_webhook_endpoint_setup: Schema.optionalKey<Schema.Boolean>;
+  }>, 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 { TriggersTypeListResponse };

package/dist/effect/schemas/triggers-types/list.mjs

@@ -0,0 +1,90 @@
+import * as Schema from "effect/Schema";
+
+//#region src/effect/generated/schemas/triggers-types/list.ts
+/** The 200 response of `GET /api/v3.1/triggers_types`, which `client.triggersTypes.list` answers with. */
+const TriggersTypeListResponse = Schema.StructWithRest(Schema.Struct({
+	"items": Schema.Array(Schema.StructWithRest(Schema.Struct({
+		"slug": Schema.String.annotate({
+			"description": "Unique identifier for the trigger type",
+			"examples": ["SLACK_CHANNEL_MESSAGE_RECEIVED"]
+		}),
+		"name": Schema.String.annotate({
+			"description": "Human-readable name of the trigger",
+			"examples": ["New Message in Slack Channel"]
+		}),
+		"description": Schema.String.annotate({
+			"description": "Detailed description of what the trigger does",
+			"examples": ["Triggers when a new message is posted to a Slack channel"]
+		}),
+		"instructions": Schema.String.annotate({ "description": "Step-by-step instructions on how to set up and use this trigger" }),
+		"type": Schema.Literals(["webhook", "poll"]).annotate({
+			"description": "Deprecated: use types. poll for any trigger that polls, even one a webhook wakes; otherwise webhook.",
+			"examples": ["webhook"]
+		}),
+		"types": Schema.Array(Schema.Literals(["webhook", "poll"])).annotate({
+			"description": "The trigger mechanisms this trigger supports, in order of preference: webhook (event-based) before poll (scheduled check).",
+			"examples": [["webhook", "poll"]]
+		}).check(Schema.isMinLength(1).annotate({ "expected": "a value with a length of at least 1" })),
+		"toolkit": Schema.StructWithRest(Schema.Struct({
+			"slug": Schema.String.annotate({
+				"description": "Unique identifier for the parent toolkit",
+				"examples": ["slack"]
+			}),
+			"name": Schema.String.annotate({
+				"description": "Deprecated: Use slug instead",
+				"examples": ["Slack"]
+			}),
+			"logo": Schema.String.annotate({
+				"description": "Logo of the toolkit",
+				"examples": ["https://example.com/logo.png"]
+			})
+		}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))]).annotate({ "description": "Information about the toolkit that provides this trigger" }),
+		"config": Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({
+			"description": "Configuration schema required to set up this trigger",
+			"examples": [{
+				"channel_id": {
+					"type": "string",
+					"required": true
+				},
+				"message_type": {
+					"type": "enum",
+					"options": [
+						"all",
+						"direct",
+						"channel"
+					]
+				}
+			}]
+		}),
+		"payload": Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" })).annotate({
+			"description": "Schema of the data payload this trigger will deliver when it fires",
+			"examples": [{
+				"message": { "type": "string" },
+				"sender": {
+					"type": "object",
+					"properties": {
+						"id": "string",
+						"name": "string"
+					}
+				},
+				"timestamp": { "type": "number" }
+			}]
+		}),
+		"version": Schema.String.annotate({
+			"description": "Version of the trigger type",
+			"examples": ["20250930_00"]
+		}),
+		"requires_webhook_endpoint_setup": Schema.optionalKey(Schema.Boolean.annotate({
+			"description": "True when the developer must register a Composio-issued webhook URL with the upstream provider (e.g. Slack Event Subscriptions, Notion integration webhooks). See the webhook_endpoint API for the setup.",
+			"default": false,
+			"examples": [false]
+		}))
+	}), [Schema.Record(Schema.String, Schema.Json.annotate({ "expected": "JSON value" }))])),
+	"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 { TriggersTypeListResponse };

package/dist/effect/schemas/triggers-types/retrieve-enum.d.mts

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

package/dist/effect/schemas/triggers-types/retrieve-enum.mjs

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

package/dist/effect/schemas/triggers-types/retrieve.d.mts

@@ -0,0 +1,22 @@
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/schemas/triggers-types/retrieve.d.ts
+/** The 200 response of `GET /api/v3.1/triggers_types/{slug}`, which `client.triggersTypes.retrieve` answers with. */
+declare const TriggersTypeRetrieveResponse: Schema.StructWithRest<Schema.Struct<{
+  readonly slug: Schema.String;
+  readonly name: Schema.String;
+  readonly description: Schema.String;
+  readonly instructions: Schema.String;
+  readonly type: Schema.Literals<readonly ["webhook", "poll"]>;
+  readonly types: Schema.$Array<Schema.Literals<readonly ["webhook", "poll"]>>;
+  readonly toolkit: Schema.StructWithRest<Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly name: Schema.String;
+    readonly logo: Schema.String;
+  }>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly config: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  readonly version: Schema.String;
+  readonly requires_webhook_endpoint_setup: Schema.optionalKey<Schema.Boolean>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+//#endregion
+export { TriggersTypeRetrieveResponse };