@ekanos/integration-schema 0.1.0

package/dist/integration-definition.d.ts

@@ -0,0 +1,1771 @@
+/**
+ * The canonical integration-definition contract: ONE zod schema and ONE set
+ * of inferred/hand-written types (F9). `@ekanos/sdk`'s `defineIntegration()`
+ * validates against this schema at authoring time; `@kit/integrations-core`'s
+ * `registerPartnerIntegration()` re-validates against the SAME schema at the
+ * host trust boundary (F3). Both packages depend on this one; it depends on
+ * neither, so there is no cycle and no hand-written structural twin.
+ *
+ * Dependency-pure (zod only): partner component refs are checked
+ * structurally via `ComponentReference`, so no React dependency leaks in.
+ */
+import { z } from 'zod';
+import type { IntegrationContext, StorageKeyDeclarationInput, StorageSchemas } from './capability-context.js';
+import type { ComponentReference } from './component-reference.js';
+import { type WorkspaceTargetDefinition } from './workspace-target.js';
+type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+declare const capabilitySchema: z.ZodObject<{
+    label: z.ZodString;
+    description: z.ZodString;
+    icon: z.ZodOptional<z.ZodType<ComponentReference, z.ZodTypeDef, ComponentReference>>;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    label: string;
+    icon?: ComponentReference | undefined;
+}, {
+    description: string;
+    label: string;
+    icon?: ComponentReference | undefined;
+}>;
+declare const permissionSchema: z.ZodObject<{
+    label: z.ZodString;
+    detail: z.ZodString;
+    type: z.ZodEnum<["read", "write"]>;
+}, "strict", z.ZodTypeAny, {
+    type: "read" | "write";
+    label: string;
+    detail: string;
+}, {
+    type: "read" | "write";
+    label: string;
+    detail: string;
+}>;
+/**
+ * F7: authorable widget fields ONLY. Host-resolved fields (`productId`,
+ * `widgetConfigId`, `workspaceId`, `collapsed`, `isPinned`, `health`,
+ * `integrationMetadata`) are absent by design and rejected at runtime by
+ * `.strict()` — the type and the runtime agree. The host adapter maps this
+ * into the full `WidgetConfig`.
+ */
+declare const widgetSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    component: z.ZodType<ComponentReference, z.ZodTypeDef, ComponentReference>;
+    widgetState: z.ZodEnum<["active", "inactive", "disabled"]>;
+    gridSize: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        cols: z.ZodNumber;
+        rows: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        cols: number;
+        rows: number;
+    }, {
+        cols: number;
+        rows: number;
+    }>, z.ZodArray<z.ZodObject<{
+        cols: z.ZodNumber;
+        rows: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        cols: number;
+        rows: number;
+    }, {
+        cols: number;
+        rows: number;
+    }>, "many">]>>;
+    gridPosition: z.ZodOptional<z.ZodObject<{
+        col: z.ZodNumber;
+        row: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        col: number;
+        row: number;
+    }, {
+        col: number;
+        row: number;
+    }>>;
+    layouts: z.ZodOptional<z.ZodObject<{
+        lg: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+            maxHeight: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        }, {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        }>>;
+        md: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+            maxHeight: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        }, {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        }>>;
+        sm: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+            maxHeight: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        }, {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        lg?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+        md?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+        sm?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+    }, {
+        lg?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+        md?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+        sm?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+    }>>;
+    category: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        slug: z.ZodString;
+        icon: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        slug: string;
+        name: string;
+        icon: string | null;
+        id: string;
+    }, {
+        slug: string;
+        name: string;
+        icon: string | null;
+        id: string;
+    }>>;
+    isCollapsible: z.ZodOptional<z.ZodBoolean>;
+    isPinnable: z.ZodOptional<z.ZodBoolean>;
+    aiFooterEnabled: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    component: ComponentReference;
+    widgetState: "active" | "inactive" | "disabled";
+    gridSize?: {
+        cols: number;
+        rows: number;
+    } | {
+        cols: number;
+        rows: number;
+    }[] | undefined;
+    gridPosition?: {
+        col: number;
+        row: number;
+    } | undefined;
+    layouts?: {
+        lg?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+        md?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+        sm?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+    } | undefined;
+    category?: {
+        slug: string;
+        name: string;
+        icon: string | null;
+        id: string;
+    } | undefined;
+    isCollapsible?: boolean | undefined;
+    isPinnable?: boolean | undefined;
+    aiFooterEnabled?: boolean | undefined;
+}, {
+    name: string;
+    id: string;
+    component: ComponentReference;
+    widgetState: "active" | "inactive" | "disabled";
+    gridSize?: {
+        cols: number;
+        rows: number;
+    } | {
+        cols: number;
+        rows: number;
+    }[] | undefined;
+    gridPosition?: {
+        col: number;
+        row: number;
+    } | undefined;
+    layouts?: {
+        lg?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+        md?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+        sm?: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            maxHeight?: number | undefined;
+        } | undefined;
+    } | undefined;
+    category?: {
+        slug: string;
+        name: string;
+        icon: string | null;
+        id: string;
+    } | undefined;
+    isCollapsible?: boolean | undefined;
+    isPinnable?: boolean | undefined;
+    aiFooterEnabled?: boolean | undefined;
+}>;
+declare const toolParametersSchema: z.ZodObject<{
+    type: z.ZodLiteral<"object">;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>>;
+    required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    additionalProperties: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    type: "object";
+    properties?: Record<string, JsonValue> | undefined;
+    required?: string[] | undefined;
+    additionalProperties?: boolean | undefined;
+}, {
+    type: "object";
+    properties?: Record<string, JsonValue> | undefined;
+    required?: string[] | undefined;
+    additionalProperties?: boolean | undefined;
+}>;
+declare const toolClassificationProposalSchema: z.ZodObject<{
+    effect: z.ZodOptional<z.ZodEnum<["read", "write"]>>;
+    sensitivity: z.ZodOptional<z.ZodEnum<["public", "internal", "pii", "financial"]>>;
+}, "strict", z.ZodTypeAny, {
+    effect?: "read" | "write" | undefined;
+    sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+}, {
+    effect?: "read" | "write" | undefined;
+    sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+}>;
+declare const proposalsSchema: z.ZodObject<{
+    credentialModel: z.ZodOptional<z.ZodEnum<["account", "user", "source"]>>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        effect: z.ZodOptional<z.ZodEnum<["read", "write"]>>;
+        sensitivity: z.ZodOptional<z.ZodEnum<["public", "internal", "pii", "financial"]>>;
+    }, "strict", z.ZodTypeAny, {
+        effect?: "read" | "write" | undefined;
+        sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+    }, {
+        effect?: "read" | "write" | undefined;
+        sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+    }>>>;
+}, "strict", z.ZodTypeAny, {
+    credentialModel?: "user" | "account" | "source" | undefined;
+    tools?: Record<string, {
+        effect?: "read" | "write" | undefined;
+        sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+    }> | undefined;
+}, {
+    credentialModel?: "user" | "account" | "source" | undefined;
+    tools?: Record<string, {
+        effect?: "read" | "write" | undefined;
+        sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+    }> | undefined;
+}>;
+/**
+ * THE canonical schema. Strict everywhere: an unrecognized key is an error,
+ * which is what keeps host-assigned fields (productId, kind, trust tier,
+ * credentialModel, per-tool effect/sensitivity, host-resolved widget fields)
+ * structurally un-settable at runtime, not merely absent from the type.
+ */
+export declare const IntegrationDefinitionSchema: z.ZodEffects<z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodString;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodString;
+        icon: z.ZodOptional<z.ZodType<ComponentReference, z.ZodTypeDef, ComponentReference>>;
+    }, "strict", z.ZodTypeAny, {
+        description: string;
+        label: string;
+        icon?: ComponentReference | undefined;
+    }, {
+        description: string;
+        label: string;
+        icon?: ComponentReference | undefined;
+    }>, "many">>;
+    permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        detail: z.ZodString;
+        type: z.ZodEnum<["read", "write"]>;
+    }, "strict", z.ZodTypeAny, {
+        type: "read" | "write";
+        label: string;
+        detail: string;
+    }, {
+        type: "read" | "write";
+        label: string;
+        detail: string;
+    }>, "many">>;
+    components: z.ZodOptional<z.ZodObject<{
+        activationForm: z.ZodOptional<z.ZodType<ComponentReference, z.ZodTypeDef, ComponentReference>>;
+        marketplaceTile: z.ZodOptional<z.ZodType<ComponentReference, z.ZodTypeDef, ComponentReference>>;
+        widgets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            component: z.ZodType<ComponentReference, z.ZodTypeDef, ComponentReference>;
+            widgetState: z.ZodEnum<["active", "inactive", "disabled"]>;
+            gridSize: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+                cols: z.ZodNumber;
+                rows: z.ZodNumber;
+            }, "strict", z.ZodTypeAny, {
+                cols: number;
+                rows: number;
+            }, {
+                cols: number;
+                rows: number;
+            }>, z.ZodArray<z.ZodObject<{
+                cols: z.ZodNumber;
+                rows: z.ZodNumber;
+            }, "strict", z.ZodTypeAny, {
+                cols: number;
+                rows: number;
+            }, {
+                cols: number;
+                rows: number;
+            }>, "many">]>>;
+            gridPosition: z.ZodOptional<z.ZodObject<{
+                col: z.ZodNumber;
+                row: z.ZodNumber;
+            }, "strict", z.ZodTypeAny, {
+                col: number;
+                row: number;
+            }, {
+                col: number;
+                row: number;
+            }>>;
+            layouts: z.ZodOptional<z.ZodObject<{
+                lg: z.ZodOptional<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                    maxHeight: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                }, {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                }>>;
+                md: z.ZodOptional<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                    maxHeight: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                }, {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                }>>;
+                sm: z.ZodOptional<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                    maxHeight: z.ZodOptional<z.ZodNumber>;
+                }, "strict", z.ZodTypeAny, {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                }, {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                }>>;
+            }, "strict", z.ZodTypeAny, {
+                lg?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                md?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                sm?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+            }, {
+                lg?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                md?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                sm?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+            }>>;
+            category: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                slug: z.ZodString;
+                icon: z.ZodNullable<z.ZodString>;
+            }, "strict", z.ZodTypeAny, {
+                slug: string;
+                name: string;
+                icon: string | null;
+                id: string;
+            }, {
+                slug: string;
+                name: string;
+                icon: string | null;
+                id: string;
+            }>>;
+            isCollapsible: z.ZodOptional<z.ZodBoolean>;
+            isPinnable: z.ZodOptional<z.ZodBoolean>;
+            aiFooterEnabled: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            id: string;
+            component: ComponentReference;
+            widgetState: "active" | "inactive" | "disabled";
+            gridSize?: {
+                cols: number;
+                rows: number;
+            } | {
+                cols: number;
+                rows: number;
+            }[] | undefined;
+            gridPosition?: {
+                col: number;
+                row: number;
+            } | undefined;
+            layouts?: {
+                lg?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                md?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                sm?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+            } | undefined;
+            category?: {
+                slug: string;
+                name: string;
+                icon: string | null;
+                id: string;
+            } | undefined;
+            isCollapsible?: boolean | undefined;
+            isPinnable?: boolean | undefined;
+            aiFooterEnabled?: boolean | undefined;
+        }, {
+            name: string;
+            id: string;
+            component: ComponentReference;
+            widgetState: "active" | "inactive" | "disabled";
+            gridSize?: {
+                cols: number;
+                rows: number;
+            } | {
+                cols: number;
+                rows: number;
+            }[] | undefined;
+            gridPosition?: {
+                col: number;
+                row: number;
+            } | undefined;
+            layouts?: {
+                lg?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                md?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                sm?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+            } | undefined;
+            category?: {
+                slug: string;
+                name: string;
+                icon: string | null;
+                id: string;
+            } | undefined;
+            isCollapsible?: boolean | undefined;
+            isPinnable?: boolean | undefined;
+            aiFooterEnabled?: boolean | undefined;
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        activationForm?: ComponentReference | undefined;
+        marketplaceTile?: ComponentReference | undefined;
+        widgets?: {
+            name: string;
+            id: string;
+            component: ComponentReference;
+            widgetState: "active" | "inactive" | "disabled";
+            gridSize?: {
+                cols: number;
+                rows: number;
+            } | {
+                cols: number;
+                rows: number;
+            }[] | undefined;
+            gridPosition?: {
+                col: number;
+                row: number;
+            } | undefined;
+            layouts?: {
+                lg?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                md?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                sm?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+            } | undefined;
+            category?: {
+                slug: string;
+                name: string;
+                icon: string | null;
+                id: string;
+            } | undefined;
+            isCollapsible?: boolean | undefined;
+            isPinnable?: boolean | undefined;
+            aiFooterEnabled?: boolean | undefined;
+        }[] | undefined;
+    }, {
+        activationForm?: ComponentReference | undefined;
+        marketplaceTile?: ComponentReference | undefined;
+        widgets?: {
+            name: string;
+            id: string;
+            component: ComponentReference;
+            widgetState: "active" | "inactive" | "disabled";
+            gridSize?: {
+                cols: number;
+                rows: number;
+            } | {
+                cols: number;
+                rows: number;
+            }[] | undefined;
+            gridPosition?: {
+                col: number;
+                row: number;
+            } | undefined;
+            layouts?: {
+                lg?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                md?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                sm?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+            } | undefined;
+            category?: {
+                slug: string;
+                name: string;
+                icon: string | null;
+                id: string;
+            } | undefined;
+            isCollapsible?: boolean | undefined;
+            isPinnable?: boolean | undefined;
+            aiFooterEnabled?: boolean | undefined;
+        }[] | undefined;
+    }>>;
+    workspaceTargets: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodObject<{
+        slug: z.ZodString;
+        name: z.ZodString;
+        icon: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+        description: z.ZodOptional<z.ZodString>;
+        layout: z.ZodDefault<z.ZodEnum<["masonry", "two-column"]>>;
+        inheritsWidgets: z.ZodOptional<z.ZodBoolean>;
+        includedWidgetIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        slug: string;
+        name: string;
+        layout: "masonry" | "two-column";
+        description?: string | undefined;
+        icon?: string | undefined;
+        inheritsWidgets?: boolean | undefined;
+        includedWidgetIds?: string[] | undefined;
+    }, {
+        slug: string;
+        name: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        layout?: "masonry" | "two-column" | undefined;
+        inheritsWidgets?: boolean | undefined;
+        includedWidgetIds?: string[] | undefined;
+    }>, {
+        slug: string;
+        name: string;
+        layout: "masonry" | "two-column";
+        description?: string | undefined;
+        icon?: string | undefined;
+        inheritsWidgets?: boolean | undefined;
+        includedWidgetIds?: string[] | undefined;
+    }, {
+        slug: string;
+        name: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        layout?: "masonry" | "two-column" | undefined;
+        inheritsWidgets?: boolean | undefined;
+        includedWidgetIds?: string[] | undefined;
+    }>, "many">, {
+        slug: string;
+        name: string;
+        layout: "masonry" | "two-column";
+        description?: string | undefined;
+        icon?: string | undefined;
+        inheritsWidgets?: boolean | undefined;
+        includedWidgetIds?: string[] | undefined;
+    }[], {
+        slug: string;
+        name: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        layout?: "masonry" | "two-column" | undefined;
+        inheritsWidgets?: boolean | undefined;
+        includedWidgetIds?: string[] | undefined;
+    }[]>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        parameters: z.ZodOptional<z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            additionalProperties: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            type: "object";
+            properties?: Record<string, JsonValue> | undefined;
+            required?: string[] | undefined;
+            additionalProperties?: boolean | undefined;
+        }, {
+            type: "object";
+            properties?: Record<string, JsonValue> | undefined;
+            required?: string[] | undefined;
+            additionalProperties?: boolean | undefined;
+        }>>;
+        run: z.ZodType<(ctx: never, args: Record<string, unknown>) => Promise<unknown>, z.ZodTypeDef, (ctx: never, args: Record<string, unknown>) => Promise<unknown>>;
+        outputExample: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>>;
+    }, "strict", z.ZodTypeAny, {
+        description: string;
+        name: string;
+        run: (ctx: never, args: Record<string, unknown>) => Promise<unknown>;
+        parameters?: {
+            type: "object";
+            properties?: Record<string, JsonValue> | undefined;
+            required?: string[] | undefined;
+            additionalProperties?: boolean | undefined;
+        } | undefined;
+        outputExample?: Record<string, JsonValue> | undefined;
+    }, {
+        description: string;
+        name: string;
+        run: (ctx: never, args: Record<string, unknown>) => Promise<unknown>;
+        parameters?: {
+            type: "object";
+            properties?: Record<string, JsonValue> | undefined;
+            required?: string[] | undefined;
+            additionalProperties?: boolean | undefined;
+        } | undefined;
+        outputExample?: Record<string, JsonValue> | undefined;
+    }>, "many">>;
+    storage: z.ZodOptional<z.ZodObject<{
+        account: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodType<StorageKeyDeclarationInput, z.ZodTypeDef, StorageKeyDeclarationInput>, StorageKeyDeclarationInput, StorageKeyDeclarationInput>>>;
+        user: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodType<StorageKeyDeclarationInput, z.ZodTypeDef, StorageKeyDeclarationInput>, StorageKeyDeclarationInput, StorageKeyDeclarationInput>>>;
+    }, "strict", z.ZodTypeAny, {
+        user?: Record<string, StorageKeyDeclarationInput> | undefined;
+        account?: Record<string, StorageKeyDeclarationInput> | undefined;
+    }, {
+        user?: Record<string, StorageKeyDeclarationInput> | undefined;
+        account?: Record<string, StorageKeyDeclarationInput> | undefined;
+    }>>;
+    egress: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    webhooks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        payloadSchema: z.ZodType<z.ZodType<any, z.ZodTypeDef, any>, z.ZodTypeDef, z.ZodType<any, z.ZodTypeDef, any>>;
+        signature: z.ZodUnion<[z.ZodLiteral<"none">, z.ZodObject<{
+            header: z.ZodString;
+            secretName: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            header: string;
+            secretName: string;
+        }, {
+            header: string;
+            secretName: string;
+        }>]>;
+        examplePayload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>>;
+        handler: z.ZodType<(ctx: never, arg: never) => Promise<unknown>, z.ZodTypeDef, (ctx: never, arg: never) => Promise<unknown>>;
+    }, "strict", z.ZodTypeAny, {
+        description: string;
+        id: string;
+        payloadSchema: z.ZodType<any, z.ZodTypeDef, any>;
+        signature: "none" | {
+            header: string;
+            secretName: string;
+        };
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        examplePayload?: Record<string, JsonValue> | undefined;
+    }, {
+        description: string;
+        id: string;
+        payloadSchema: z.ZodType<any, z.ZodTypeDef, any>;
+        signature: "none" | {
+            header: string;
+            secretName: string;
+        };
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        examplePayload?: Record<string, JsonValue> | undefined;
+    }>, "many">>;
+    schedules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        cron: z.ZodString;
+        handler: z.ZodType<(ctx: never, arg: never) => Promise<unknown>, z.ZodTypeDef, (ctx: never, arg: never) => Promise<unknown>>;
+    }, "strict", z.ZodTypeAny, {
+        description: string;
+        id: string;
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        cron: string;
+    }, {
+        description: string;
+        id: string;
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        cron: string;
+    }>, "many">>;
+    oauth: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodObject<{
+            authorizationUrl: z.ZodEffects<z.ZodString, string, string>;
+            tokenUrl: z.ZodEffects<z.ZodString, string, string>;
+            scopes: z.ZodArray<z.ZodString, "many">;
+            pkce: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            authorizationUrl: string;
+            tokenUrl: string;
+            scopes: string[];
+            pkce?: boolean | undefined;
+        }, {
+            authorizationUrl: string;
+            tokenUrl: string;
+            scopes: string[];
+            pkce?: boolean | undefined;
+        }>;
+        credentials: z.ZodObject<{
+            clientIdSecretName: z.ZodString;
+            clientSecretSecretName: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            clientIdSecretName: string;
+            clientSecretSecretName: string;
+        }, {
+            clientIdSecretName: string;
+            clientSecretSecretName: string;
+        }>;
+        onTokens: z.ZodType<(ctx: never, arg: never) => Promise<unknown>, z.ZodTypeDef, (ctx: never, arg: never) => Promise<unknown>>;
+    }, "strict", z.ZodTypeAny, {
+        provider: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            scopes: string[];
+            pkce?: boolean | undefined;
+        };
+        credentials: {
+            clientIdSecretName: string;
+            clientSecretSecretName: string;
+        };
+        onTokens: (ctx: never, arg: never) => Promise<unknown>;
+    }, {
+        provider: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            scopes: string[];
+            pkce?: boolean | undefined;
+        };
+        credentials: {
+            clientIdSecretName: string;
+            clientSecretSecretName: string;
+        };
+        onTokens: (ctx: never, arg: never) => Promise<unknown>;
+    }>>;
+    proposes: z.ZodOptional<z.ZodObject<{
+        credentialModel: z.ZodOptional<z.ZodEnum<["account", "user", "source"]>>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            effect: z.ZodOptional<z.ZodEnum<["read", "write"]>>;
+            sensitivity: z.ZodOptional<z.ZodEnum<["public", "internal", "pii", "financial"]>>;
+        }, "strict", z.ZodTypeAny, {
+            effect?: "read" | "write" | undefined;
+            sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+        }, {
+            effect?: "read" | "write" | undefined;
+            sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+        }>>>;
+    }, "strict", z.ZodTypeAny, {
+        credentialModel?: "user" | "account" | "source" | undefined;
+        tools?: Record<string, {
+            effect?: "read" | "write" | undefined;
+            sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+        }> | undefined;
+    }, {
+        credentialModel?: "user" | "account" | "source" | undefined;
+        tools?: Record<string, {
+            effect?: "read" | "write" | undefined;
+            sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+        }> | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    slug: string;
+    name: string;
+    version: string;
+    tools?: {
+        description: string;
+        name: string;
+        run: (ctx: never, args: Record<string, unknown>) => Promise<unknown>;
+        parameters?: {
+            type: "object";
+            properties?: Record<string, JsonValue> | undefined;
+            required?: string[] | undefined;
+            additionalProperties?: boolean | undefined;
+        } | undefined;
+        outputExample?: Record<string, JsonValue> | undefined;
+    }[] | undefined;
+    capabilities?: {
+        description: string;
+        label: string;
+        icon?: ComponentReference | undefined;
+    }[] | undefined;
+    permissions?: {
+        type: "read" | "write";
+        label: string;
+        detail: string;
+    }[] | undefined;
+    components?: {
+        activationForm?: ComponentReference | undefined;
+        marketplaceTile?: ComponentReference | undefined;
+        widgets?: {
+            name: string;
+            id: string;
+            component: ComponentReference;
+            widgetState: "active" | "inactive" | "disabled";
+            gridSize?: {
+                cols: number;
+                rows: number;
+            } | {
+                cols: number;
+                rows: number;
+            }[] | undefined;
+            gridPosition?: {
+                col: number;
+                row: number;
+            } | undefined;
+            layouts?: {
+                lg?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                md?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                sm?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+            } | undefined;
+            category?: {
+                slug: string;
+                name: string;
+                icon: string | null;
+                id: string;
+            } | undefined;
+            isCollapsible?: boolean | undefined;
+            isPinnable?: boolean | undefined;
+            aiFooterEnabled?: boolean | undefined;
+        }[] | undefined;
+    } | undefined;
+    workspaceTargets?: {
+        slug: string;
+        name: string;
+        layout: "masonry" | "two-column";
+        description?: string | undefined;
+        icon?: string | undefined;
+        inheritsWidgets?: boolean | undefined;
+        includedWidgetIds?: string[] | undefined;
+    }[] | undefined;
+    storage?: {
+        user?: Record<string, StorageKeyDeclarationInput> | undefined;
+        account?: Record<string, StorageKeyDeclarationInput> | undefined;
+    } | undefined;
+    egress?: string[] | undefined;
+    webhooks?: {
+        description: string;
+        id: string;
+        payloadSchema: z.ZodType<any, z.ZodTypeDef, any>;
+        signature: "none" | {
+            header: string;
+            secretName: string;
+        };
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        examplePayload?: Record<string, JsonValue> | undefined;
+    }[] | undefined;
+    schedules?: {
+        description: string;
+        id: string;
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        cron: string;
+    }[] | undefined;
+    oauth?: {
+        provider: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            scopes: string[];
+            pkce?: boolean | undefined;
+        };
+        credentials: {
+            clientIdSecretName: string;
+            clientSecretSecretName: string;
+        };
+        onTokens: (ctx: never, arg: never) => Promise<unknown>;
+    } | undefined;
+    proposes?: {
+        credentialModel?: "user" | "account" | "source" | undefined;
+        tools?: Record<string, {
+            effect?: "read" | "write" | undefined;
+            sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+        }> | undefined;
+    } | undefined;
+}, {
+    description: string;
+    slug: string;
+    name: string;
+    version: string;
+    tools?: {
+        description: string;
+        name: string;
+        run: (ctx: never, args: Record<string, unknown>) => Promise<unknown>;
+        parameters?: {
+            type: "object";
+            properties?: Record<string, JsonValue> | undefined;
+            required?: string[] | undefined;
+            additionalProperties?: boolean | undefined;
+        } | undefined;
+        outputExample?: Record<string, JsonValue> | undefined;
+    }[] | undefined;
+    capabilities?: {
+        description: string;
+        label: string;
+        icon?: ComponentReference | undefined;
+    }[] | undefined;
+    permissions?: {
+        type: "read" | "write";
+        label: string;
+        detail: string;
+    }[] | undefined;
+    components?: {
+        activationForm?: ComponentReference | undefined;
+        marketplaceTile?: ComponentReference | undefined;
+        widgets?: {
+            name: string;
+            id: string;
+            component: ComponentReference;
+            widgetState: "active" | "inactive" | "disabled";
+            gridSize?: {
+                cols: number;
+                rows: number;
+            } | {
+                cols: number;
+                rows: number;
+            }[] | undefined;
+            gridPosition?: {
+                col: number;
+                row: number;
+            } | undefined;
+            layouts?: {
+                lg?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                md?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                sm?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+            } | undefined;
+            category?: {
+                slug: string;
+                name: string;
+                icon: string | null;
+                id: string;
+            } | undefined;
+            isCollapsible?: boolean | undefined;
+            isPinnable?: boolean | undefined;
+            aiFooterEnabled?: boolean | undefined;
+        }[] | undefined;
+    } | undefined;
+    workspaceTargets?: {
+        slug: string;
+        name: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        layout?: "masonry" | "two-column" | undefined;
+        inheritsWidgets?: boolean | undefined;
+        includedWidgetIds?: string[] | undefined;
+    }[] | undefined;
+    storage?: {
+        user?: Record<string, StorageKeyDeclarationInput> | undefined;
+        account?: Record<string, StorageKeyDeclarationInput> | undefined;
+    } | undefined;
+    egress?: string[] | undefined;
+    webhooks?: {
+        description: string;
+        id: string;
+        payloadSchema: z.ZodType<any, z.ZodTypeDef, any>;
+        signature: "none" | {
+            header: string;
+            secretName: string;
+        };
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        examplePayload?: Record<string, JsonValue> | undefined;
+    }[] | undefined;
+    schedules?: {
+        description: string;
+        id: string;
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        cron: string;
+    }[] | undefined;
+    oauth?: {
+        provider: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            scopes: string[];
+            pkce?: boolean | undefined;
+        };
+        credentials: {
+            clientIdSecretName: string;
+            clientSecretSecretName: string;
+        };
+        onTokens: (ctx: never, arg: never) => Promise<unknown>;
+    } | undefined;
+    proposes?: {
+        credentialModel?: "user" | "account" | "source" | undefined;
+        tools?: Record<string, {
+            effect?: "read" | "write" | undefined;
+            sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+        }> | undefined;
+    } | undefined;
+}>, {
+    description: string;
+    slug: string;
+    name: string;
+    version: string;
+    tools?: {
+        description: string;
+        name: string;
+        run: (ctx: never, args: Record<string, unknown>) => Promise<unknown>;
+        parameters?: {
+            type: "object";
+            properties?: Record<string, JsonValue> | undefined;
+            required?: string[] | undefined;
+            additionalProperties?: boolean | undefined;
+        } | undefined;
+        outputExample?: Record<string, JsonValue> | undefined;
+    }[] | undefined;
+    capabilities?: {
+        description: string;
+        label: string;
+        icon?: ComponentReference | undefined;
+    }[] | undefined;
+    permissions?: {
+        type: "read" | "write";
+        label: string;
+        detail: string;
+    }[] | undefined;
+    components?: {
+        activationForm?: ComponentReference | undefined;
+        marketplaceTile?: ComponentReference | undefined;
+        widgets?: {
+            name: string;
+            id: string;
+            component: ComponentReference;
+            widgetState: "active" | "inactive" | "disabled";
+            gridSize?: {
+                cols: number;
+                rows: number;
+            } | {
+                cols: number;
+                rows: number;
+            }[] | undefined;
+            gridPosition?: {
+                col: number;
+                row: number;
+            } | undefined;
+            layouts?: {
+                lg?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                md?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                sm?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+            } | undefined;
+            category?: {
+                slug: string;
+                name: string;
+                icon: string | null;
+                id: string;
+            } | undefined;
+            isCollapsible?: boolean | undefined;
+            isPinnable?: boolean | undefined;
+            aiFooterEnabled?: boolean | undefined;
+        }[] | undefined;
+    } | undefined;
+    workspaceTargets?: {
+        slug: string;
+        name: string;
+        layout: "masonry" | "two-column";
+        description?: string | undefined;
+        icon?: string | undefined;
+        inheritsWidgets?: boolean | undefined;
+        includedWidgetIds?: string[] | undefined;
+    }[] | undefined;
+    storage?: {
+        user?: Record<string, StorageKeyDeclarationInput> | undefined;
+        account?: Record<string, StorageKeyDeclarationInput> | undefined;
+    } | undefined;
+    egress?: string[] | undefined;
+    webhooks?: {
+        description: string;
+        id: string;
+        payloadSchema: z.ZodType<any, z.ZodTypeDef, any>;
+        signature: "none" | {
+            header: string;
+            secretName: string;
+        };
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        examplePayload?: Record<string, JsonValue> | undefined;
+    }[] | undefined;
+    schedules?: {
+        description: string;
+        id: string;
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        cron: string;
+    }[] | undefined;
+    oauth?: {
+        provider: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            scopes: string[];
+            pkce?: boolean | undefined;
+        };
+        credentials: {
+            clientIdSecretName: string;
+            clientSecretSecretName: string;
+        };
+        onTokens: (ctx: never, arg: never) => Promise<unknown>;
+    } | undefined;
+    proposes?: {
+        credentialModel?: "user" | "account" | "source" | undefined;
+        tools?: Record<string, {
+            effect?: "read" | "write" | undefined;
+            sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+        }> | undefined;
+    } | undefined;
+}, {
+    description: string;
+    slug: string;
+    name: string;
+    version: string;
+    tools?: {
+        description: string;
+        name: string;
+        run: (ctx: never, args: Record<string, unknown>) => Promise<unknown>;
+        parameters?: {
+            type: "object";
+            properties?: Record<string, JsonValue> | undefined;
+            required?: string[] | undefined;
+            additionalProperties?: boolean | undefined;
+        } | undefined;
+        outputExample?: Record<string, JsonValue> | undefined;
+    }[] | undefined;
+    capabilities?: {
+        description: string;
+        label: string;
+        icon?: ComponentReference | undefined;
+    }[] | undefined;
+    permissions?: {
+        type: "read" | "write";
+        label: string;
+        detail: string;
+    }[] | undefined;
+    components?: {
+        activationForm?: ComponentReference | undefined;
+        marketplaceTile?: ComponentReference | undefined;
+        widgets?: {
+            name: string;
+            id: string;
+            component: ComponentReference;
+            widgetState: "active" | "inactive" | "disabled";
+            gridSize?: {
+                cols: number;
+                rows: number;
+            } | {
+                cols: number;
+                rows: number;
+            }[] | undefined;
+            gridPosition?: {
+                col: number;
+                row: number;
+            } | undefined;
+            layouts?: {
+                lg?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                md?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+                sm?: {
+                    x: number;
+                    y: number;
+                    w: number;
+                    h: number;
+                    maxHeight?: number | undefined;
+                } | undefined;
+            } | undefined;
+            category?: {
+                slug: string;
+                name: string;
+                icon: string | null;
+                id: string;
+            } | undefined;
+            isCollapsible?: boolean | undefined;
+            isPinnable?: boolean | undefined;
+            aiFooterEnabled?: boolean | undefined;
+        }[] | undefined;
+    } | undefined;
+    workspaceTargets?: {
+        slug: string;
+        name: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+        layout?: "masonry" | "two-column" | undefined;
+        inheritsWidgets?: boolean | undefined;
+        includedWidgetIds?: string[] | undefined;
+    }[] | undefined;
+    storage?: {
+        user?: Record<string, StorageKeyDeclarationInput> | undefined;
+        account?: Record<string, StorageKeyDeclarationInput> | undefined;
+    } | undefined;
+    egress?: string[] | undefined;
+    webhooks?: {
+        description: string;
+        id: string;
+        payloadSchema: z.ZodType<any, z.ZodTypeDef, any>;
+        signature: "none" | {
+            header: string;
+            secretName: string;
+        };
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        examplePayload?: Record<string, JsonValue> | undefined;
+    }[] | undefined;
+    schedules?: {
+        description: string;
+        id: string;
+        handler: (ctx: never, arg: never) => Promise<unknown>;
+        cron: string;
+    }[] | undefined;
+    oauth?: {
+        provider: {
+            authorizationUrl: string;
+            tokenUrl: string;
+            scopes: string[];
+            pkce?: boolean | undefined;
+        };
+        credentials: {
+            clientIdSecretName: string;
+            clientSecretSecretName: string;
+        };
+        onTokens: (ctx: never, arg: never) => Promise<unknown>;
+    } | undefined;
+    proposes?: {
+        credentialModel?: "user" | "account" | "source" | undefined;
+        tools?: Record<string, {
+            effect?: "read" | "write" | undefined;
+            sensitivity?: "public" | "internal" | "pii" | "financial" | undefined;
+        }> | undefined;
+    } | undefined;
+}>;
+export type ToolClassificationProposal = z.infer<typeof toolClassificationProposalSchema>;
+export type IntegrationProposals = z.infer<typeof proposalsSchema>;
+export type PartnerToolParameters = z.infer<typeof toolParametersSchema>;
+export type IntegrationCapabilityDeclaration = z.infer<typeof capabilitySchema>;
+export type IntegrationPermissionDeclaration = z.infer<typeof permissionSchema>;
+export type PartnerWidgetDeclaration = z.infer<typeof widgetSchema>;
+export interface PartnerToolModule<Schemas extends StorageSchemas = StorageSchemas> {
+    name: string;
+    description: string;
+    parameters?: PartnerToolParameters;
+    /**
+     * Contravariant function property (F8): the declared `Schemas` generic
+     * types `ctx.storage` for the author. The generic cannot survive the
+     * by-value, monomorphic host registration boundary — the adapter erases it
+     * — but nothing rests on it surviving: the host constructs `ctx` FROM the
+     * definition's own `storage` schemas, and `ctx.storage` validates every
+     * read/write against them at runtime regardless of the handler's
+     * annotation. The static generic is DX; the runtime schema is the guard.
+     */
+    run: (ctx: IntegrationContext<Schemas>, args: Record<string, unknown>) => Promise<unknown>;
+    outputExample?: Record<string, JsonValue>;
+}
+export interface IntegrationComponentDeclarations {
+    activationForm?: ComponentReference;
+    marketplaceTile?: ComponentReference;
+    widgets?: PartnerWidgetDeclaration[];
+}
+/**
+ * How the transport verifies a webhook delivery. `'none'` states explicitly
+ * that the source is unsigned; otherwise the transport reads the named header
+ * and verifies it against the named secret. Verification is the TRANSPORT's
+ * job (the local harness logs it as skipped; the host ingress enforces it) —
+ * never the partner handler's.
+ */
+export type WebhookSignatureDeclaration = 'none' | {
+    header: string;
+    secretName: string;
+};
+/**
+ * One delivery, as the handler receives it: transport-assigned id and receipt
+ * time, the delivery headers, and the payload ALREADY parsed and validated
+ * against the declaration's `payloadSchema`. A payload that fails the schema
+ * never reaches the handler.
+ */
+export interface WebhookEvent {
+    id: string;
+    /** ISO-8601 — when the transport accepted the delivery. */
+    receivedAt: string;
+    headers: Record<string, string>;
+    /** The parsed, schema-validated payload (output of `payloadSchema`). */
+    payload: unknown;
+}
+/**
+ * What the handler tells the transport. `processed` acknowledges the event;
+ * `ignored` acknowledges it as irrelevant (still a 2xx — the sender must not
+ * retry). A handler that cannot process a valid event THROWS, which the
+ * transport maps to a retryable failure.
+ */
+export interface WebhookResult {
+    status: 'processed' | 'ignored';
+    detail?: string;
+}
+export interface PartnerWebhookDeclaration<Schemas extends StorageSchemas = StorageSchemas> {
+    id: string;
+    description: string;
+    /** Validates every delivery before the handler runs. */
+    payloadSchema: z.ZodType;
+    signature: WebhookSignatureDeclaration;
+    /**
+     * A representative payload, JSON-compatible. Seeds the harness's payload
+     * editor and documents the shape beside the schema.
+     */
+    examplePayload?: Record<string, JsonValue>;
+    handler: (ctx: IntegrationContext<Schemas>, event: WebhookEvent) => Promise<WebhookResult>;
+}
+/**
+ * One firing, as the handler receives it. `trigger` distinguishes the real
+ * scheduler from a human pressing "Run now" (harness or admin) — handlers may
+ * branch on it (e.g. skip idempotency windows for manual runs) but must be
+ * safe under both.
+ */
+export interface ScheduleInvocation {
+    /** ISO-8601 — the tick this invocation stands for. */
+    scheduledFor: string;
+    /** ISO-8601 — when the handler actually started. */
+    invokedAt: string;
+    trigger: 'schedule' | 'manual';
+}
+/**
+ * `completed` means the run did its work; `skipped` means it correctly did
+ * nothing (not configured, nothing to do). A handler that fails THROWS, which
+ * the transport records as a failed run.
+ */
+export interface ScheduleResult {
+    status: 'completed' | 'skipped';
+    detail?: string;
+}
+export interface PartnerScheduleDeclaration<Schemas extends StorageSchemas = StorageSchemas> {
+    id: string;
+    description: string;
+    /**
+     * Standard 5-field cron (minute hour day-of-month month day-of-week),
+     * validated by `defineIntegration()`. The schema package checks presence
+     * only — full syntax validation is the SDK layer's job.
+     */
+    cron: string;
+    handler: (ctx: IntegrationContext<Schemas>, invocation: ScheduleInvocation) => Promise<ScheduleResult>;
+}
+/**
+ * The token set the transport hands `onTokens` after a code exchange (and
+ * after each refresh). `raw` carries provider-specific extras verbatim.
+ */
+export interface OAuthTokens {
+    accessToken: string;
+    refreshToken?: string;
+    /** ISO-8601 expiry, when the provider reports one. */
+    expiresAt?: string;
+    scope?: string;
+    tokenType?: string;
+    raw?: Record<string, JsonValue>;
+}
+export interface OAuthProviderDeclaration {
+    authorizationUrl: string;
+    tokenUrl: string;
+    scopes: string[];
+    pkce?: boolean;
+}
+/**
+ * The OAuth contract. The TRANSPORT owns the flow (authorize redirect, state,
+ * callback, code exchange — localhost in the harness, hosted later); the
+ * partner declares the provider endpoints, names the client-credential
+ * secrets, and persists tokens in `onTokens` via `ctx.secrets` — so token
+ * storage policy is the existing capability layer, nothing new.
+ * `defineIntegration()` rejects the declaration unless both endpoint origins
+ * are covered by the definition's `egress` list.
+ */
+export interface PartnerOAuthDeclaration<Schemas extends StorageSchemas = StorageSchemas> {
+    provider: OAuthProviderDeclaration;
+    credentials: {
+        clientIdSecretName: string;
+        clientSecretSecretName: string;
+    };
+    onTokens: (ctx: IntegrationContext<Schemas>, tokens: OAuthTokens) => Promise<void>;
+}
+export interface IntegrationDefinition<Schemas extends StorageSchemas = StorageSchemas> {
+    slug: string;
+    name: string;
+    description: string;
+    version: string;
+    capabilities?: IntegrationCapabilityDeclaration[];
+    permissions?: IntegrationPermissionDeclaration[];
+    components?: IntegrationComponentDeclarations;
+    workspaceTargets?: WorkspaceTargetDefinition[];
+    tools?: PartnerToolModule<Schemas>[];
+    storage?: Schemas;
+    egress?: string[];
+    webhooks?: PartnerWebhookDeclaration<Schemas>[];
+    schedules?: PartnerScheduleDeclaration<Schemas>[];
+    oauth?: PartnerOAuthDeclaration<Schemas>;
+    proposes?: IntegrationProposals;
+}
+/**
+ * F4: reject accessor/proxy/class-instance/cyclic declaration containers
+ * before parsing. An object with getters (or a proxy) can return validated
+ * values during parse and different values later; a non-plain prototype can
+ * smuggle mutable state past `z.object()`; a cycle would recurse into zod
+ * rather than fail cleanly. We walk every CONTAINER (plain object / array),
+ * and stop at legitimate leaves: functions (component refs, `run`) and zod
+ * schemas (storage). Leaf detection happens BEFORE any own-property read, so
+ * a `safeParse` getter cannot execute. Proxy detection is best-effort — the
+ * re-parse at the host boundary (which materializes fresh values via zod) is
+ * the real guard.
+ *
+ * Cycle detection tracks the ANCESTOR chain only (add on enter, remove on
+ * exit): a genuine back-edge is a cycle, but the same object referenced from
+ * two sibling branches (a DAG — e.g. a shallow-cloned widget sharing a
+ * `layouts` object) is not, and must not be rejected.
+ */
+export declare function assertPlainDeclaration(value: unknown, path?: string, ancestors?: WeakSet<object>): void;
+/**
+ * Cycle-aware deep freeze (F4). Freezes plain objects and arrays; leaves zod
+ * schemas (freezing breaks their internal caches) and functions alone.
+ */
+export declare function deepFreezeDefinition(value: unknown): void;
+/**
+ * The single validation entry point used by BOTH `defineIntegration()` (SDK,
+ * authoring time) and `registerPartnerIntegration()` (core, host trust
+ * boundary — F3). Rejects non-plain containers, then parses against the
+ * canonical schema, and returns the SANITIZED `result.data` (fresh, plain,
+ * strict-stripped — never the caller's original object). Throws an Error
+ * whose message is a remediation instruction.
+ */
+export declare function parseIntegrationDefinition(input: unknown): IntegrationDefinition;
+/**
+ * THE canonical effective MCP tool name — the single source of truth for how
+ * discovery keys a tool. Tool discovery namespaces each raw tool name with the
+ * integration slug (`slug.replace(/-/g,'_')`), skipping the prefix when the
+ * name already carries it. Two collision-free RAW pairs can therefore collapse
+ * to the same EFFECTIVE name (`{slug:"foo",tool:"bar_baz"}` and
+ * `{slug:"foo-bar",tool:"baz"}` both become `foo_bar_baz`), so collision
+ * checking MUST compare effective names, and runtime discovery MUST throw on a
+ * duplicate assignment. Both call this one helper
+ * (`packages/agents/src/tools/tool-discovery.ts`).
+ */
+export declare function getDiscoveredToolName(slug: string, rawName: string): string;
+/**
+ * The metadata-only shape collision checking needs — no handlers, no schemas
+ * (F8: collision validation must not force widening the tool handlers). A
+ * full `IntegrationDefinition` is assignable to it.
+ */
+export interface DefinitionCollisionInput {
+    slug: string;
+    components?: {
+        widgets?: readonly {
+            id: string;
+        }[];
+    } | null;
+    tools?: readonly {
+        name: string;
+    }[] | null;
+}
+/**
+ * First-party identifiers a partner definition must not collide with (F5).
+ * Widget lookup matches on `widget.id` and the assistant's tool list is a
+ * flat name-keyed map where a later registration overwrites an earlier one,
+ * so a partner reusing a first-party id/name silently hijacks it. Sourced
+ * from the reviewed registry inventory, not from executing partner handlers.
+ */
+export interface FirstPartyInventory {
+    slugs?: readonly string[];
+    widgetIds?: readonly string[];
+    /**
+     * EFFECTIVE (discovery) tool names — `getDiscoveredToolName(slug, rawName)` —
+     * NOT raw names, since discovery keys the flat registry by the effective name.
+     */
+    toolNames?: readonly string[];
+}
+/**
+ * Detects cross-definition collisions (duplicate slugs, widget ids, tool
+ * names across the partner set) AND collisions against the first-party
+ * inventory, throwing one error listing EVERY collision.
+ *
+ * This is the build-time gate the host registry deliberately lacks:
+ * `integrationRegistry.register()` keys by slug via `Map.set` and silently
+ * OVERWRITES, and duplicate widget/tool ids resolve last- or
+ * first-registration-wins by import order.
+ */
+export declare function validateIntegrationDefinitions(definitions: readonly DefinitionCollisionInput[], firstParty?: FirstPartyInventory): void;
+export {};