@opengeni/contracts 3.1.0-canary.1 → 3.1.2

package/dist/connection-authority.d.ts

@@ -1,290 +1,7 @@
 import { z } from "zod";
-/** The only generic grant action that authorizes use of a connection. */
-export declare const ConnectionUseAction: z.ZodLiteral<"connection.use">;
-export type ConnectionUseAction = z.infer<typeof ConnectionUseAction>;
-/**
- * Connection authority is either workspace-owned or user-owned. Omission is
- * intentionally compatible with the historical workspace connection path.
- */
-export declare const ConnectionAuthorityEnvelope: z.ZodObject<{
-    scope: z.ZodDefault<z.ZodEnum<{
-        user: "user";
-        workspace: "workspace";
-    }>>;
-    userDelegation: z.ZodOptional<z.ZodObject<{
-        authorityId: z.ZodString;
-        grantId: z.ZodString;
-        organizationId: z.ZodString;
-        workspaceId: z.ZodString;
-        sessionId: z.ZodNullable<z.ZodString>;
-        action: z.ZodString;
-        mode: z.ZodEnum<{
-            always: "always";
-            once: "once";
-            session: "session";
-        }>;
-        context: z.ZodEnum<{
-            user_private: "user_private";
-            workspace_shared: "workspace_shared";
-        }>;
-        authorityEpoch: z.ZodNullable<z.ZodNumber>;
-        authorityGeneration: z.ZodNumber;
-        grantGeneration: z.ZodNumber;
-        resourceVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strict>;
-export type ConnectionAuthorityEnvelope = z.infer<typeof ConnectionAuthorityEnvelope>;
-export declare const ConnectionAuthorityGrant: z.ZodObject<{
-    grantId: z.ZodString;
-    targetWorkspaceId: z.ZodString;
-    targetSessionId: z.ZodNullable<z.ZodString>;
-    mode: z.ZodEnum<{
-        always: "always";
-        once: "once";
-        session: "session";
-    }>;
-    context: z.ZodEnum<{
-        user_private: "user_private";
-        workspace_shared: "workspace_shared";
-    }>;
-    authorityEpoch: z.ZodNullable<z.ZodNumber>;
-    generation: z.ZodNumber;
-    status: z.ZodEnum<{
-        active: "active";
-        consumed: "consumed";
-        expired: "expired";
-        revoked: "revoked";
-    }>;
-    expiresAt: z.ZodNullable<z.ZodString>;
-    delegation: z.ZodLazy<z.ZodObject<{
-        authorityId: z.ZodString;
-        grantId: z.ZodString;
-        organizationId: z.ZodString;
-        workspaceId: z.ZodString;
-        sessionId: z.ZodNullable<z.ZodString>;
-        action: z.ZodString;
-        mode: z.ZodEnum<{
-            always: "always";
-            once: "once";
-            session: "session";
-        }>;
-        context: z.ZodEnum<{
-            user_private: "user_private";
-            workspace_shared: "workspace_shared";
-        }>;
-        authorityEpoch: z.ZodNullable<z.ZodNumber>;
-        authorityGeneration: z.ZodNumber;
-        grantGeneration: z.ZodNumber;
-        resourceVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>>;
-    action: z.ZodLiteral<"connection.use">;
-}, z.core.$strict>;
-export type ConnectionAuthorityGrant = z.infer<typeof ConnectionAuthorityGrant>;
-/** Owner-only opaque projection; connection identity and owner metadata stay server-side. */
-export declare const ConnectionAuthoritySummary: z.ZodObject<{
-    authorityId: z.ZodString;
-    resourceId: z.ZodString;
-    originWorkspaceId: z.ZodNullable<z.ZodString>;
-    generation: z.ZodNumber;
-    status: z.ZodEnum<{
-        active: "active";
-        retained: "retained";
-        revoked: "revoked";
-    }>;
-    grants: z.ZodArray<z.ZodObject<{
-        grantId: z.ZodString;
-        targetWorkspaceId: z.ZodString;
-        targetSessionId: z.ZodNullable<z.ZodString>;
-        mode: z.ZodEnum<{
-            always: "always";
-            once: "once";
-            session: "session";
-        }>;
-        context: z.ZodEnum<{
-            user_private: "user_private";
-            workspace_shared: "workspace_shared";
-        }>;
-        authorityEpoch: z.ZodNullable<z.ZodNumber>;
-        generation: z.ZodNumber;
-        status: z.ZodEnum<{
-            active: "active";
-            consumed: "consumed";
-            expired: "expired";
-            revoked: "revoked";
-        }>;
-        expiresAt: z.ZodNullable<z.ZodString>;
-        delegation: z.ZodLazy<z.ZodObject<{
-            authorityId: z.ZodString;
-            grantId: z.ZodString;
-            organizationId: z.ZodString;
-            workspaceId: z.ZodString;
-            sessionId: z.ZodNullable<z.ZodString>;
-            action: z.ZodString;
-            mode: z.ZodEnum<{
-                always: "always";
-                once: "once";
-                session: "session";
-            }>;
-            context: z.ZodEnum<{
-                user_private: "user_private";
-                workspace_shared: "workspace_shared";
-            }>;
-            authorityEpoch: z.ZodNullable<z.ZodNumber>;
-            authorityGeneration: z.ZodNumber;
-            grantGeneration: z.ZodNumber;
-            resourceVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>>;
-        action: z.ZodLiteral<"connection.use">;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ConnectionAuthoritySummary = z.infer<typeof ConnectionAuthoritySummary>;
-export declare const ListConnectionAuthoritiesQuery: z.ZodObject<{
-    scope: z.ZodLiteral<"user">;
-    cursor: z.ZodOptional<z.ZodString>;
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-}, z.core.$strict>;
-export declare const ListConnectionAuthoritiesResponse: z.ZodObject<{
-    scope: z.ZodLiteral<"user">;
-    authorities: z.ZodArray<z.ZodObject<{
-        authorityId: z.ZodString;
-        resourceId: z.ZodString;
-        originWorkspaceId: z.ZodNullable<z.ZodString>;
-        generation: z.ZodNumber;
-        status: z.ZodEnum<{
-            active: "active";
-            retained: "retained";
-            revoked: "revoked";
-        }>;
-        grants: z.ZodArray<z.ZodObject<{
-            grantId: z.ZodString;
-            targetWorkspaceId: z.ZodString;
-            targetSessionId: z.ZodNullable<z.ZodString>;
-            mode: z.ZodEnum<{
-                always: "always";
-                once: "once";
-                session: "session";
-            }>;
-            context: z.ZodEnum<{
-                user_private: "user_private";
-                workspace_shared: "workspace_shared";
-            }>;
-            authorityEpoch: z.ZodNullable<z.ZodNumber>;
-            generation: z.ZodNumber;
-            status: z.ZodEnum<{
-                active: "active";
-                consumed: "consumed";
-                expired: "expired";
-                revoked: "revoked";
-            }>;
-            expiresAt: z.ZodNullable<z.ZodString>;
-            delegation: z.ZodLazy<z.ZodObject<{
-                authorityId: z.ZodString;
-                grantId: z.ZodString;
-                organizationId: z.ZodString;
-                workspaceId: z.ZodString;
-                sessionId: z.ZodNullable<z.ZodString>;
-                action: z.ZodString;
-                mode: z.ZodEnum<{
-                    always: "always";
-                    once: "once";
-                    session: "session";
-                }>;
-                context: z.ZodEnum<{
-                    user_private: "user_private";
-                    workspace_shared: "workspace_shared";
-                }>;
-                authorityEpoch: z.ZodNullable<z.ZodNumber>;
-                authorityGeneration: z.ZodNumber;
-                grantGeneration: z.ZodNumber;
-                resourceVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            }, z.core.$strip>>;
-            action: z.ZodLiteral<"connection.use">;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    nextCursor: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export declare const IssueConnectionUseGrantRequest: z.ZodObject<{
-    scope: z.ZodLiteral<"user">;
-    mode: z.ZodEnum<{
-        always: "always";
-        session: "session";
-    }>;
-    context: z.ZodEnum<{
-        user_private: "user_private";
-        workspace_shared: "workspace_shared";
-    }>;
-    sessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    expectedAuthorityEpoch: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    workspaceSharedAcknowledged: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strict>;
-export type IssueConnectionUseGrantRequest = z.infer<typeof IssueConnectionUseGrantRequest>;
-export declare const RevokeConnectionUseGrantQuery: z.ZodObject<{
-    scope: z.ZodLiteral<"user">;
-}, z.core.$strict>;
-export declare const ConnectionUseGrantMutationResponse: z.ZodObject<{
-    scope: z.ZodLiteral<"user">;
-    grant: z.ZodObject<{
-        grantId: z.ZodString;
-        targetWorkspaceId: z.ZodString;
-        targetSessionId: z.ZodNullable<z.ZodString>;
-        mode: z.ZodEnum<{
-            always: "always";
-            once: "once";
-            session: "session";
-        }>;
-        context: z.ZodEnum<{
-            user_private: "user_private";
-            workspace_shared: "workspace_shared";
-        }>;
-        authorityEpoch: z.ZodNullable<z.ZodNumber>;
-        generation: z.ZodNumber;
-        status: z.ZodEnum<{
-            active: "active";
-            consumed: "consumed";
-            expired: "expired";
-            revoked: "revoked";
-        }>;
-        expiresAt: z.ZodNullable<z.ZodString>;
-        delegation: z.ZodLazy<z.ZodObject<{
-            authorityId: z.ZodString;
-            grantId: z.ZodString;
-            organizationId: z.ZodString;
-            workspaceId: z.ZodString;
-            sessionId: z.ZodNullable<z.ZodString>;
-            action: z.ZodString;
-            mode: z.ZodEnum<{
-                always: "always";
-                once: "once";
-                session: "session";
-            }>;
-            context: z.ZodEnum<{
-                user_private: "user_private";
-                workspace_shared: "workspace_shared";
-            }>;
-            authorityEpoch: z.ZodNullable<z.ZodNumber>;
-            authorityGeneration: z.ZodNumber;
-            grantGeneration: z.ZodNumber;
-            resourceVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>>;
-        action: z.ZodLiteral<"connection.use">;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type ConnectionUseGrantMutationResponse = z.infer<typeof ConnectionUseGrantMutationResponse>;
-export declare const ConnectionUseGrantRevocationResponse: z.ZodObject<{
-    scope: z.ZodLiteral<"user">;
-    grant: z.ZodObject<{
-        grantId: z.ZodString;
-        generation: z.ZodNumber;
-        status: z.ZodLiteral<"revoked">;
-        revokedAt: z.ZodString;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type ConnectionUseGrantRevocationResponse = z.infer<typeof ConnectionUseGrantRevocationResponse>;
 export declare const ConnectionAuthoritySelectionSource: z.ZodEnum<{
     explicit_workspace: "explicit_workspace";
-    legacy_user_compatibility: "legacy_user_compatibility";
-    legacy_workspace_omission: "legacy_workspace_omission";
-    user_delegation: "user_delegation";
+    sender: "sender";
 }>;
 export type ConnectionAuthoritySelectionSource = z.infer<typeof ConnectionAuthoritySelectionSource>;
 export declare const ConnectionUseSelectionSource: z.ZodString;
@@ -324,7 +41,6 @@ export declare const ConnectionUseAuthoritySnapshot: z.ZodObject<{
         oauth2: "oauth2";
     }>;
     scope: z.ZodEnum<{
-        legacy_user: "legacy_user";
         user: "user";
         workspace: "workspace";
     }>;
@@ -333,32 +49,10 @@ export declare const ConnectionUseAuthoritySnapshot: z.ZodObject<{
     ownerMembershipAuthorizationRevision: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
     authoritySource: z.ZodEnum<{
         explicit_workspace: "explicit_workspace";
-        legacy_user_compatibility: "legacy_user_compatibility";
-        legacy_workspace_omission: "legacy_workspace_omission";
-        user_delegation: "user_delegation";
+        sender: "sender";
     }>;
     selectionSources: z.ZodArray<z.ZodString>;
-    userDelegation: z.ZodNullable<z.ZodObject<{
-        authorityId: z.ZodString;
-        grantId: z.ZodString;
-        organizationId: z.ZodString;
-        workspaceId: z.ZodString;
-        sessionId: z.ZodNullable<z.ZodString>;
-        action: z.ZodString;
-        mode: z.ZodEnum<{
-            always: "always";
-            once: "once";
-            session: "session";
-        }>;
-        context: z.ZodEnum<{
-            user_private: "user_private";
-            workspace_shared: "workspace_shared";
-        }>;
-        authorityEpoch: z.ZodNullable<z.ZodNumber>;
-        authorityGeneration: z.ZodNumber;
-        grantGeneration: z.ZodNumber;
-        resourceVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>>;
+    userDelegation: z.ZodNull;
 }, z.core.$strict>;
 export type ConnectionUseAuthoritySnapshot = z.infer<typeof ConnectionUseAuthoritySnapshot>;
 export declare const ConnectionUseDenialReason: z.ZodEnum<{
@@ -395,14 +89,13 @@ export declare const ConnectionUseAttribution: z.ZodObject<{
     sessionId: z.ZodString;
     connectionId: z.ZodString;
     connectionGeneration: z.ZodNumber;
+    ownerSubjectId: z.ZodNullable<z.ZodString>;
+    authorityId: z.ZodNullable<z.ZodString>;
     scope: z.ZodEnum<{
-        legacy_user: "legacy_user";
         user: "user";
         workspace: "workspace";
     }>;
-    ownerSubjectId: z.ZodNullable<z.ZodString>;
-    authorityId: z.ZodNullable<z.ZodString>;
-    grantId: z.ZodNullable<z.ZodString>;
+    grantId: z.ZodNull;
 }, z.core.$strict>;
 export type ConnectionUseAttribution = z.infer<typeof ConnectionUseAttribution>;
 export declare const ConnectionUseAuditFact: z.ZodObject<{
@@ -460,14 +153,13 @@ export declare const ConnectionUseAuthorizationResult: z.ZodDiscriminatedUnion<[
         sessionId: z.ZodString;
         connectionId: z.ZodString;
         connectionGeneration: z.ZodNumber;
+        ownerSubjectId: z.ZodNullable<z.ZodString>;
+        authorityId: z.ZodNullable<z.ZodString>;
         scope: z.ZodEnum<{
-            legacy_user: "legacy_user";
             user: "user";
             workspace: "workspace";
         }>;
-        ownerSubjectId: z.ZodNullable<z.ZodString>;
-        authorityId: z.ZodNullable<z.ZodString>;
-        grantId: z.ZodNullable<z.ZodString>;
+        grantId: z.ZodNull;
     }, z.core.$strict>;
 }, z.core.$strict>, z.ZodObject<{
     status: z.ZodLiteral<"denied">;

package/dist/connection-authority.js

@@ -1,62 +1,57 @@
 import {
-  ConnectionAuthorityEnvelope,
-  ConnectionAuthorityGrant,
   ConnectionAuthoritySelectionSource,
-  ConnectionAuthoritySummary,
-  ConnectionUseAction,
   ConnectionUseAttribution,
   ConnectionUseAuditFact,
   ConnectionUseAuthoritySnapshot,
   ConnectionUseAuthorizationResult,
   ConnectionUseDenialReason,
-  ConnectionUseGrantMutationResponse,
-  ConnectionUseGrantRevocationResponse,
-  ConnectionUseSelectionSource,
-  IssueConnectionUseGrantRequest,
-  ListConnectionAuthoritiesQuery,
-  ListConnectionAuthoritiesResponse,
-  RevokeConnectionUseGrantQuery
-} from "./chunk-OSBYTE3O.js";
-import "./chunk-UR2GFYIE.js";
-import "./chunk-WBYTNVIW.js";
-import "./chunk-YBW5JSA3.js";
-import "./chunk-O5LEQHDM.js";
-import "./chunk-GRG7PHWQ.js";
-import "./chunk-MRWYRAS5.js";
-import "./chunk-3SIZGL3O.js";
+  ConnectionUseSelectionSource
+} from "./chunk-6C2HKFTU.js";
+import "./chunk-OF6OKOBF.js";
+import "./chunk-EFZYKUE2.js";
+import "./chunk-Z7WEVGCL.js";
+import "./chunk-4JGHSSB7.js";
+import "./chunk-2ZIHHL72.js";
+import "./chunk-LZ2LAHIX.js";
+import "./chunk-NDZHPTCL.js";
+import "./chunk-SHO4YO4B.js";
+import "./chunk-TSWWZMUS.js";
+import "./chunk-XDLAGX66.js";
+import "./chunk-4VDMHLLL.js";
+import "./chunk-E3GGUBHS.js";
+import "./chunk-KHHZTBP7.js";
+import "./chunk-6IXO76Z6.js";
 import "./chunk-NVJMJWLL.js";
+import "./chunk-352X6ENP.js";
 import "./chunk-YRKRZ6OF.js";
-import "./chunk-JUFK3T4Q.js";
-import "./chunk-M5ZGRVIQ.js";
-import "./chunk-BCS7WHCK.js";
-import "./chunk-5LYFSZ7O.js";
-import "./chunk-Y3KNXVTD.js";
-import "./chunk-D2HKF2EF.js";
-import "./chunk-TXTQIYCV.js";
+import "./chunk-J4HQ3UKY.js";
+import "./chunk-YKZ4WU4P.js";
+import "./chunk-TLU3UEMD.js";
+import "./chunk-OL23ARTF.js";
+import "./chunk-TCXCRBPF.js";
+import "./chunk-ZDCRWCGZ.js";
+import "./chunk-SWRN2DJ3.js";
+import "./chunk-HRRU4QPI.js";
+import "./chunk-IK36LXKC.js";
 import "./chunk-RIY7GYQS.js";
+import "./chunk-4QO6GJUX.js";
+import "./chunk-EKWNTOG3.js";
+import "./chunk-56SNIMDO.js";
+import "./chunk-D2HKF2EF.js";
 import "./chunk-MYBZRDTY.js";
-import "./chunk-PX3VCKAU.js";
-import "./chunk-YRXAWWCU.js";
-import "./chunk-WYBDERIY.js";
-import "./chunk-P3HLDT77.js";
-import "./chunk-7ABONTXE.js";
+import "./chunk-PUIUXIOL.js";
+import "./chunk-RKX3NQYS.js";
+import "./chunk-7272KVWZ.js";
+import "./chunk-RMWXDZEO.js";
+import "./chunk-ILJ72KPO.js";
+import "./chunk-WVCFSOUZ.js";
 export {
-  ConnectionAuthorityEnvelope,
-  ConnectionAuthorityGrant,
   ConnectionAuthoritySelectionSource,
-  ConnectionAuthoritySummary,
-  ConnectionUseAction,
   ConnectionUseAttribution,
   ConnectionUseAuditFact,
   ConnectionUseAuthoritySnapshot,
   ConnectionUseAuthorizationResult,
   ConnectionUseDenialReason,
-  ConnectionUseGrantMutationResponse,
-  ConnectionUseGrantRevocationResponse,
-  ConnectionUseSelectionSource,
-  IssueConnectionUseGrantRequest,
-  ListConnectionAuthoritiesQuery,
-  ListConnectionAuthoritiesResponse,
-  RevokeConnectionUseGrantQuery
+  ConnectionUseSelectionSource
 };
 //# sourceMappingURL=connection-authority.js.map

package/dist/connector-attachments.js

@@ -22,7 +22,8 @@ import {
   ConnectorAttachmentTransfer,
   ConnectorAttachmentTransferEnvelope,
   parseConnectorAttachmentTransferEnvelope
-} from "./chunk-YBW5JSA3.js";
+} from "./chunk-ZDCRWCGZ.js";
+import "./chunk-56SNIMDO.js";
 export {
   CONNECTOR_ATTACHMENT_FILENAME_MAX_UTF8_BYTES,
   CONNECTOR_ATTACHMENT_MAX_BYTES,

package/dist/connector-destinations.js

@@ -7,7 +7,8 @@ import {
   connectorDocumentDestinationCollectionId,
   legacyWorkspaceConnectorDocumentDestination,
   resolveConnectorDocumentDestination
-} from "./chunk-WYBDERIY.js";
+} from "./chunk-LZ2LAHIX.js";
+import "./chunk-56SNIMDO.js";
 export {
   ConnectorDocumentDestination,
   ConnectorDocumentDestinationAuthority,

package/dist/connector-tool-permissions.d.ts

@@ -0,0 +1,137 @@
+import { z } from "zod";
+export declare const ConnectorToolPermission: z.ZodEnum<{
+    allow: "allow";
+    ask: "ask";
+    block: "block";
+}>;
+export type ConnectorToolPermission = z.infer<typeof ConnectorToolPermission>;
+export declare const ConnectorToolPermissionEntry: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    group: z.ZodEnum<{
+        other: "other";
+        read: "read";
+        write: "write";
+    }>;
+    permission: z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        block: "block";
+    }>;
+    inherited: z.ZodBoolean;
+    resetReason: z.ZodOptional<z.ZodLiteral<"operation_changed">>;
+    approvalRequired: z.ZodBoolean;
+    source: z.ZodOptional<z.ZodEnum<{
+        action: "action";
+        conflict: "conflict";
+        connector_default: "connector_default";
+        recommended: "recommended";
+        tool: "tool";
+    }>>;
+    conditional: z.ZodOptional<z.ZodBoolean>;
+    actionPermissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        actionName: z.ZodString;
+        permission: z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            block: "block";
+        }>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ConnectorToolPermissionEntry = z.infer<typeof ConnectorToolPermissionEntry>;
+export declare const ConnectorToolPermissionsResponse: z.ZodObject<{
+    connectionId: z.ZodString;
+    serverId: z.ZodString;
+    defaultPermission: z.ZodNullable<z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        block: "block";
+    }>>;
+    tools: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        group: z.ZodEnum<{
+            other: "other";
+            read: "read";
+            write: "write";
+        }>;
+        permission: z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            block: "block";
+        }>;
+        inherited: z.ZodBoolean;
+        resetReason: z.ZodOptional<z.ZodLiteral<"operation_changed">>;
+        approvalRequired: z.ZodBoolean;
+        source: z.ZodOptional<z.ZodEnum<{
+            action: "action";
+            conflict: "conflict";
+            connector_default: "connector_default";
+            recommended: "recommended";
+            tool: "tool";
+        }>>;
+        conditional: z.ZodOptional<z.ZodBoolean>;
+        actionPermissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            actionName: z.ZodString;
+            permission: z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                block: "block";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    discoveryError: z.ZodNullable<z.ZodString>;
+    canManage: z.ZodBoolean;
+    appliesTo: z.ZodOptional<z.ZodLiteral<"next_attempt">>;
+    revision: z.ZodOptional<z.ZodString>;
+    accountLabel: z.ZodOptional<z.ZodString>;
+    instanceKey: z.ZodOptional<z.ZodString>;
+    accounts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        connectionId: z.ZodString;
+        label: z.ZodString;
+        scope: z.ZodEnum<{
+            none: "none";
+            personal: "personal";
+            workspace: "workspace";
+        }>;
+        instanceKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ConnectorToolPermissionsResponse = z.infer<typeof ConnectorToolPermissionsResponse>;
+export declare const UpdateConnectorToolPermissionsRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    connectionId: z.ZodString;
+    target: z.ZodLiteral<"default">;
+    permission: z.ZodNullable<z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        block: "block";
+    }>>;
+    expectedRevision: z.ZodOptional<z.ZodString>;
+    instanceKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    connectionId: z.ZodString;
+    target: z.ZodLiteral<"tools">;
+    toolNames: z.ZodArray<z.ZodString>;
+    permission: z.ZodNullable<z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        block: "block";
+    }>>;
+    expectedRevision: z.ZodOptional<z.ZodString>;
+    instanceKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    connectionId: z.ZodString;
+    target: z.ZodLiteral<"action">;
+    toolName: z.ZodString;
+    actionName: z.ZodString;
+    permission: z.ZodNullable<z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        block: "block";
+    }>>;
+    expectedRevision: z.ZodOptional<z.ZodString>;
+    instanceKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "target">;
+export type UpdateConnectorToolPermissionsRequest = z.infer<typeof UpdateConnectorToolPermissionsRequest>;

package/dist/cua-desktop-tools.d.ts

@@ -0,0 +1,17 @@
+/** Generated from the bundled CUA worker's listToolsJson(). Never from a live desktop. */
+export type CuaDesktopTool = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    annotations: Record<string, boolean>;
+    capabilities: string[];
+};
+export declare const CUA_DESKTOP_TOOLS: readonly CuaDesktopTool[];
+export declare const CUA_LINUX_DESKTOP_TOOLS: readonly CuaDesktopTool[];
+/** Windows publishes its own input schemas and omits tools it does not implement. */
+export declare const CUA_WINDOWS_DESKTOP_TOOLS: readonly CuaDesktopTool[];
+export declare function cuaDesktopToolsFor(platform: "macos" | "windows" | "linux"): readonly CuaDesktopTool[];
+/** Keep platform contracts intact; the session's worker enforces its own variant. */
+export declare function cuaDesktopToolVariants(name: string): readonly CuaDesktopTool[];
+export declare function isCuaDesktopModelTool(name: string | null): boolean;

package/dist/define-schema.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Construct a schema eagerly, but give bundlers one removable boundary around
+ * the whole initializer (including nested schemas and chained builders).
+ * Annotate calls with @__PURE__ only when the factory has no effects beyond
+ * constructing its returned schema. This is not lazy validation: used schemas
+ * are created once, in the same module evaluation order as ordinary constants.
+ */
+export declare function defineSchema<Schema>(factory: () => Schema): Schema;