@opengeni/contracts 0.22.0 → 0.26.1

package/dist/workspace-state.d.ts

@@ -0,0 +1,526 @@
+import { z } from "zod";
+export declare const WORKSPACE_STATE_MAX_ACTIVE_POLICY_HEADS = 32;
+export declare const WORKSPACE_STATE_MAX_BASES = 24;
+export declare const WORKSPACE_STATE_MAX_TOPICS = 24;
+export declare const WORKSPACE_STATE_MAX_GAPS = 16;
+export declare const WORKSPACE_STATE_BASE_NAME_MAX_CHARS = 160;
+export declare const WORKSPACE_STATE_TOPIC_MAX_CHARS = 96;
+export declare const WORKSPACE_STATE_MEMORY_SAMPLE_LIMIT = 100;
+export declare const WorkspaceStateDocumentStatusCounts: z.ZodObject<{
+    queued: z.ZodNumber;
+    indexing: z.ZodNumber;
+    ready: z.ZodNumber;
+    failed: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkspaceStateDocumentStatusCounts = z.infer<typeof WorkspaceStateDocumentStatusCounts>;
+export declare const WorkspaceStateSourceKindCounts: z.ZodObject<{
+    manual_upload: z.ZodNumber;
+    meeting_transcript: z.ZodNumber;
+    repository: z.ZodNumber;
+    email: z.ZodNumber;
+    chat: z.ZodNumber;
+    document: z.ZodNumber;
+    web: z.ZodNumber;
+    other: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkspaceStateSourceKindCounts = z.infer<typeof WorkspaceStateSourceKindCounts>;
+export declare const WorkspaceStateMemoryStatusCounts: z.ZodObject<{
+    proposed: z.ZodNumber;
+    approved: z.ZodNumber;
+    rejected: z.ZodNumber;
+    active: z.ZodNumber;
+    superseded: z.ZodNumber;
+    archived: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkspaceStateMemoryStatusCounts = z.infer<typeof WorkspaceStateMemoryStatusCounts>;
+export declare const WorkspaceStateMemoryKindCounts: z.ZodObject<{
+    semantic: z.ZodNumber;
+    episodic: z.ZodNumber;
+    procedural: z.ZodNumber;
+    decision: z.ZodNumber;
+    preference: z.ZodNumber;
+}, z.core.$strict>;
+export type WorkspaceStateMemoryKindCounts = z.infer<typeof WorkspaceStateMemoryKindCounts>;
+export declare const WorkspaceStatePolicyHead: z.ZodObject<{
+    kind: z.ZodEnum<{
+        charter: "charter";
+        policy: "policy";
+    }>;
+    scope: z.ZodEnum<{
+        global: "global";
+        role: "role";
+    }>;
+    roleKey: z.ZodNullable<z.ZodString>;
+    revisionId: z.ZodString;
+    revision: z.ZodNumber;
+    contentHash: z.ZodString;
+    activationVersion: z.ZodNumber;
+    activatedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const WorkspaceStatePolicyRevisionSummary: z.ZodObject<{
+    kind: z.ZodEnum<{
+        charter: "charter";
+        policy: "policy";
+    }>;
+    scope: z.ZodEnum<{
+        global: "global";
+        role: "role";
+    }>;
+    roleKey: z.ZodNullable<z.ZodString>;
+    revisionId: z.ZodString;
+    revision: z.ZodNumber;
+    contentHash: z.ZodString;
+    provenanceSource: z.ZodEnum<{
+        human: "human";
+        knowledge_proposal: "knowledge_proposal";
+        legacy_import: "legacy_import";
+        onboarding: "onboarding";
+    }>;
+    state: z.ZodEnum<{
+        active: "active";
+        inactive: "inactive";
+    }>;
+    createdAt: z.ZodString;
+}, z.core.$strict>;
+export declare const WorkspaceStatePolicy: z.ZodObject<{
+    authority: z.ZodLiteral<"workspace_instruction_policy_heads">;
+    activeHeads: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        revisionId: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+        activationVersion: z.ZodNumber;
+        activatedAt: z.ZodString;
+    }, z.core.$strict>>;
+    activeHeadsTruncated: z.ZodBoolean;
+    latestRevision: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        revisionId: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+        provenanceSource: z.ZodEnum<{
+            human: "human";
+            knowledge_proposal: "knowledge_proposal";
+            legacy_import: "legacy_import";
+            onboarding: "onboarding";
+        }>;
+        state: z.ZodEnum<{
+            active: "active";
+            inactive: "inactive";
+        }>;
+        createdAt: z.ZodString;
+    }, z.core.$strict>>;
+    legacyRuntime: z.ZodObject<{
+        source: z.ZodEnum<{
+            deployment_default: "deployment_default";
+            workspace_override: "workspace_override";
+        }>;
+        workspaceOverrideConfigured: z.ZodBoolean;
+    }, z.core.$strict>;
+    runtimeComposition: z.ZodObject<{
+        status: z.ZodLiteral<"not_implemented">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const WorkspaceStateKnowledgeBase: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    visibleDocumentCount: z.ZodNumber;
+    statusCounts: z.ZodObject<{
+        queued: z.ZodNumber;
+        indexing: z.ZodNumber;
+        ready: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strict>;
+    latestUpdatedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const WorkspaceStateTopic: z.ZodObject<{
+    name: z.ZodString;
+    documentCount: z.ZodNumber;
+}, z.core.$strict>;
+export declare const WorkspaceStateGapCode: z.ZodEnum<{
+    failed_documents: "failed_documents";
+    missing_topic_coverage: "missing_topic_coverage";
+    no_document_bases: "no_document_bases";
+    no_memory_records: "no_memory_records";
+    no_visible_documents: "no_visible_documents";
+    partial_inventory: "partial_inventory";
+    pending_memory_review: "pending_memory_review";
+    processing_documents: "processing_documents";
+}>;
+export type WorkspaceStateGapCode = z.infer<typeof WorkspaceStateGapCode>;
+export declare const WorkspaceStateGap: z.ZodObject<{
+    code: z.ZodEnum<{
+        failed_documents: "failed_documents";
+        missing_topic_coverage: "missing_topic_coverage";
+        no_document_bases: "no_document_bases";
+        no_memory_records: "no_memory_records";
+        no_visible_documents: "no_visible_documents";
+        partial_inventory: "partial_inventory";
+        pending_memory_review: "pending_memory_review";
+        processing_documents: "processing_documents";
+    }>;
+    severity: z.ZodEnum<{
+        info: "info";
+        warning: "warning";
+    }>;
+    relatedCount: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type WorkspaceStateGap = z.infer<typeof WorkspaceStateGap>;
+export declare const WorkspaceStateKnowledgeAvailable: z.ZodObject<{
+    availability: z.ZodLiteral<"available">;
+    coverage: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+    }>;
+    baseCount: z.ZodNumber;
+    bases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        visibleDocumentCount: z.ZodNumber;
+        statusCounts: z.ZodObject<{
+            queued: z.ZodNumber;
+            indexing: z.ZodNumber;
+            ready: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, z.core.$strict>;
+        latestUpdatedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    basesTruncated: z.ZodBoolean;
+    inspectedVisibleDocumentCount: z.ZodNumber;
+    documentStatusCounts: z.ZodObject<{
+        queued: z.ZodNumber;
+        indexing: z.ZodNumber;
+        ready: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strict>;
+    sourceKindCounts: z.ZodObject<{
+        manual_upload: z.ZodNumber;
+        meeting_transcript: z.ZodNumber;
+        repository: z.ZodNumber;
+        email: z.ZodNumber;
+        chat: z.ZodNumber;
+        document: z.ZodNumber;
+        web: z.ZodNumber;
+        other: z.ZodNumber;
+    }, z.core.$strict>;
+    topics: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        documentCount: z.ZodNumber;
+    }, z.core.$strict>>;
+    topicsTruncated: z.ZodBoolean;
+    latestDocumentUpdatedAt: z.ZodNullable<z.ZodString>;
+    memorySample: z.ZodObject<{
+        recordCount: z.ZodNumber;
+        sampleLimit: z.ZodLiteral<100>;
+        limitReached: z.ZodBoolean;
+        statusCounts: z.ZodObject<{
+            proposed: z.ZodNumber;
+            approved: z.ZodNumber;
+            rejected: z.ZodNumber;
+            active: z.ZodNumber;
+            superseded: z.ZodNumber;
+            archived: z.ZodNumber;
+        }, z.core.$strict>;
+        kindCounts: z.ZodObject<{
+            semantic: z.ZodNumber;
+            episodic: z.ZodNumber;
+            procedural: z.ZodNumber;
+            decision: z.ZodNumber;
+            preference: z.ZodNumber;
+        }, z.core.$strict>;
+        preferenceAuthority: z.ZodObject<{
+            kindCountSource: z.ZodLiteral<"knowledge_memories_legacy_observations">;
+            activeAuthority: z.ZodLiteral<"structured_preference_registry">;
+        }, z.core.$strict>;
+        latestUpdatedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    gaps: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            failed_documents: "failed_documents";
+            missing_topic_coverage: "missing_topic_coverage";
+            no_document_bases: "no_document_bases";
+            no_memory_records: "no_memory_records";
+            no_visible_documents: "no_visible_documents";
+            partial_inventory: "partial_inventory";
+            pending_memory_review: "pending_memory_review";
+            processing_documents: "processing_documents";
+        }>;
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+        }>;
+        relatedCount: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const WorkspaceStateKnowledgeUnavailable: z.ZodObject<{
+    availability: z.ZodLiteral<"unavailable">;
+    reason: z.ZodLiteral<"missing_permission">;
+    requiredPermission: z.ZodLiteral<"documents:search">;
+}, z.core.$strict>;
+export declare const WorkspaceStateKnowledge: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    availability: z.ZodLiteral<"available">;
+    coverage: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+    }>;
+    baseCount: z.ZodNumber;
+    bases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        visibleDocumentCount: z.ZodNumber;
+        statusCounts: z.ZodObject<{
+            queued: z.ZodNumber;
+            indexing: z.ZodNumber;
+            ready: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, z.core.$strict>;
+        latestUpdatedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    basesTruncated: z.ZodBoolean;
+    inspectedVisibleDocumentCount: z.ZodNumber;
+    documentStatusCounts: z.ZodObject<{
+        queued: z.ZodNumber;
+        indexing: z.ZodNumber;
+        ready: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$strict>;
+    sourceKindCounts: z.ZodObject<{
+        manual_upload: z.ZodNumber;
+        meeting_transcript: z.ZodNumber;
+        repository: z.ZodNumber;
+        email: z.ZodNumber;
+        chat: z.ZodNumber;
+        document: z.ZodNumber;
+        web: z.ZodNumber;
+        other: z.ZodNumber;
+    }, z.core.$strict>;
+    topics: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        documentCount: z.ZodNumber;
+    }, z.core.$strict>>;
+    topicsTruncated: z.ZodBoolean;
+    latestDocumentUpdatedAt: z.ZodNullable<z.ZodString>;
+    memorySample: z.ZodObject<{
+        recordCount: z.ZodNumber;
+        sampleLimit: z.ZodLiteral<100>;
+        limitReached: z.ZodBoolean;
+        statusCounts: z.ZodObject<{
+            proposed: z.ZodNumber;
+            approved: z.ZodNumber;
+            rejected: z.ZodNumber;
+            active: z.ZodNumber;
+            superseded: z.ZodNumber;
+            archived: z.ZodNumber;
+        }, z.core.$strict>;
+        kindCounts: z.ZodObject<{
+            semantic: z.ZodNumber;
+            episodic: z.ZodNumber;
+            procedural: z.ZodNumber;
+            decision: z.ZodNumber;
+            preference: z.ZodNumber;
+        }, z.core.$strict>;
+        preferenceAuthority: z.ZodObject<{
+            kindCountSource: z.ZodLiteral<"knowledge_memories_legacy_observations">;
+            activeAuthority: z.ZodLiteral<"structured_preference_registry">;
+        }, z.core.$strict>;
+        latestUpdatedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    gaps: z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            failed_documents: "failed_documents";
+            missing_topic_coverage: "missing_topic_coverage";
+            no_document_bases: "no_document_bases";
+            no_memory_records: "no_memory_records";
+            no_visible_documents: "no_visible_documents";
+            partial_inventory: "partial_inventory";
+            pending_memory_review: "pending_memory_review";
+            processing_documents: "processing_documents";
+        }>;
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+        }>;
+        relatedCount: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    availability: z.ZodLiteral<"unavailable">;
+    reason: z.ZodLiteral<"missing_permission">;
+    requiredPermission: z.ZodLiteral<"documents:search">;
+}, z.core.$strict>], "availability">;
+export type WorkspaceStateKnowledge = z.infer<typeof WorkspaceStateKnowledge>;
+export declare const WorkspaceStateResponse: z.ZodObject<{
+    workspaceId: z.ZodString;
+    generatedAt: z.ZodString;
+    truth: z.ZodObject<{
+        current: z.ZodObject<{
+            source: z.ZodLiteral<"read_time_projection">;
+            capturedAt: z.ZodString;
+        }, z.core.$strict>;
+        policySnapshot: z.ZodObject<{
+            status: z.ZodLiteral<"not_captured">;
+            reason: z.ZodLiteral<"workspace_instruction_policy_snapshot_not_implemented">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        authority: z.ZodLiteral<"workspace_instruction_policy_heads">;
+        activeHeads: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                charter: "charter";
+                policy: "policy";
+            }>;
+            scope: z.ZodEnum<{
+                global: "global";
+                role: "role";
+            }>;
+            roleKey: z.ZodNullable<z.ZodString>;
+            revisionId: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+            activationVersion: z.ZodNumber;
+            activatedAt: z.ZodString;
+        }, z.core.$strict>>;
+        activeHeadsTruncated: z.ZodBoolean;
+        latestRevision: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                charter: "charter";
+                policy: "policy";
+            }>;
+            scope: z.ZodEnum<{
+                global: "global";
+                role: "role";
+            }>;
+            roleKey: z.ZodNullable<z.ZodString>;
+            revisionId: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+            provenanceSource: z.ZodEnum<{
+                human: "human";
+                knowledge_proposal: "knowledge_proposal";
+                legacy_import: "legacy_import";
+                onboarding: "onboarding";
+            }>;
+            state: z.ZodEnum<{
+                active: "active";
+                inactive: "inactive";
+            }>;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
+        legacyRuntime: z.ZodObject<{
+            source: z.ZodEnum<{
+                deployment_default: "deployment_default";
+                workspace_override: "workspace_override";
+            }>;
+            workspaceOverrideConfigured: z.ZodBoolean;
+        }, z.core.$strict>;
+        runtimeComposition: z.ZodObject<{
+            status: z.ZodLiteral<"not_implemented">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    knowledge: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        availability: z.ZodLiteral<"available">;
+        coverage: z.ZodEnum<{
+            complete: "complete";
+            partial: "partial";
+        }>;
+        baseCount: z.ZodNumber;
+        bases: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            visibleDocumentCount: z.ZodNumber;
+            statusCounts: z.ZodObject<{
+                queued: z.ZodNumber;
+                indexing: z.ZodNumber;
+                ready: z.ZodNumber;
+                failed: z.ZodNumber;
+            }, z.core.$strict>;
+            latestUpdatedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        basesTruncated: z.ZodBoolean;
+        inspectedVisibleDocumentCount: z.ZodNumber;
+        documentStatusCounts: z.ZodObject<{
+            queued: z.ZodNumber;
+            indexing: z.ZodNumber;
+            ready: z.ZodNumber;
+            failed: z.ZodNumber;
+        }, z.core.$strict>;
+        sourceKindCounts: z.ZodObject<{
+            manual_upload: z.ZodNumber;
+            meeting_transcript: z.ZodNumber;
+            repository: z.ZodNumber;
+            email: z.ZodNumber;
+            chat: z.ZodNumber;
+            document: z.ZodNumber;
+            web: z.ZodNumber;
+            other: z.ZodNumber;
+        }, z.core.$strict>;
+        topics: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            documentCount: z.ZodNumber;
+        }, z.core.$strict>>;
+        topicsTruncated: z.ZodBoolean;
+        latestDocumentUpdatedAt: z.ZodNullable<z.ZodString>;
+        memorySample: z.ZodObject<{
+            recordCount: z.ZodNumber;
+            sampleLimit: z.ZodLiteral<100>;
+            limitReached: z.ZodBoolean;
+            statusCounts: z.ZodObject<{
+                proposed: z.ZodNumber;
+                approved: z.ZodNumber;
+                rejected: z.ZodNumber;
+                active: z.ZodNumber;
+                superseded: z.ZodNumber;
+                archived: z.ZodNumber;
+            }, z.core.$strict>;
+            kindCounts: z.ZodObject<{
+                semantic: z.ZodNumber;
+                episodic: z.ZodNumber;
+                procedural: z.ZodNumber;
+                decision: z.ZodNumber;
+                preference: z.ZodNumber;
+            }, z.core.$strict>;
+            preferenceAuthority: z.ZodObject<{
+                kindCountSource: z.ZodLiteral<"knowledge_memories_legacy_observations">;
+                activeAuthority: z.ZodLiteral<"structured_preference_registry">;
+            }, z.core.$strict>;
+            latestUpdatedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        gaps: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                failed_documents: "failed_documents";
+                missing_topic_coverage: "missing_topic_coverage";
+                no_document_bases: "no_document_bases";
+                no_memory_records: "no_memory_records";
+                no_visible_documents: "no_visible_documents";
+                partial_inventory: "partial_inventory";
+                pending_memory_review: "pending_memory_review";
+                processing_documents: "processing_documents";
+            }>;
+            severity: z.ZodEnum<{
+                info: "info";
+                warning: "warning";
+            }>;
+            relatedCount: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        availability: z.ZodLiteral<"unavailable">;
+        reason: z.ZodLiteral<"missing_permission">;
+        requiredPermission: z.ZodLiteral<"documents:search">;
+    }, z.core.$strict>], "availability">;
+}, z.core.$strict>;
+export type WorkspaceStateResponse = z.infer<typeof WorkspaceStateResponse>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/contracts",
-  "version": "0.22.0",
+  "version": "0.26.1",
   "description": "Shared zod schemas and wire-contract types for the OpenGeni API.",
   "license": "Apache-2.0",
   "repository": {
@@ -21,6 +21,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./slack-bot-scopes": {
+      "types": "./dist/slack-bot-scopes.d.ts",
+      "import": "./dist/slack-bot-scopes.js"
+    },
+    "./google-drive": {
+      "types": "./dist/google-drive.d.ts",
+      "import": "./dist/google-drive.js"
     }
   },
   "publishConfig": {
@@ -28,8 +36,8 @@
     "provenance": true
   },
   "scripts": {
-    "typecheck": "tsgo --noEmit",
-    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "build": "bun ../../scripts/build-typescript-package.ts",
     "prepublishOnly": "bash ../../scripts/prepublish-guard"
   },
   "dependencies": {

package/src/checkpoint-provider-bindings.ts

@@ -0,0 +1,36 @@
+export type ModalCheckpointProviderBinding = {
+  version: 1;
+  serverUrl: string;
+  workspaceName: string;
+  environment: string;
+};
+
+/**
+ * One canonical, non-secret identity for the Modal namespace that owns a
+ * checkpoint. The same bytes are used for uniqueness, durable storage, and
+ * destructive-call fencing.
+ */
+export function canonicalModalCheckpointProviderBinding(
+  value: unknown,
+): { binding: ModalCheckpointProviderBinding; key: string } | null {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value as Partial<ModalCheckpointProviderBinding>;
+  if (
+    candidate.version !== 1 ||
+    typeof candidate.serverUrl !== "string" ||
+    candidate.serverUrl.trim().length === 0 ||
+    typeof candidate.workspaceName !== "string" ||
+    candidate.workspaceName.trim().length === 0 ||
+    typeof candidate.environment !== "string"
+  ) {
+    return null;
+  }
+  const binding: ModalCheckpointProviderBinding = {
+    version: 1,
+    serverUrl: candidate.serverUrl,
+    workspaceName: candidate.workspaceName,
+    environment: candidate.environment,
+  };
+  const key = JSON.stringify(binding);
+  return key.length <= 1024 ? { binding, key } : null;
+}

package/src/google-drive.ts

@@ -0,0 +1,101 @@
+import { z } from "zod";
+
+import { ConnectionMetadata } from "./index";
+
+export const GOOGLE_DRIVE_PROVIDER_DOMAIN = "googleapis.com" as const;
+export const GOOGLE_DRIVE_METADATA_READONLY_SCOPE =
+  "https://www.googleapis.com/auth/drive.metadata.readonly" as const;
+export const GOOGLE_DRIVE_READONLY_SCOPE =
+  "https://www.googleapis.com/auth/drive.readonly" as const;
+export const GOOGLE_DRIVE_CREDENTIAL_ROLE = "google_drive_metadata" as const;
+export const GOOGLE_DRIVE_CREDENTIAL_LABEL = "Google Drive metadata browser" as const;
+
+export const GoogleDriveTargetScope = z.enum(["user", "workspace", "organization"]);
+export type GoogleDriveTargetScope = z.infer<typeof GoogleDriveTargetScope>;
+
+export const GoogleDriveSyncCadence = z.enum(["manual", "hourly", "daily"]);
+export type GoogleDriveSyncCadence = z.infer<typeof GoogleDriveSyncCadence>;
+
+export const GoogleDriveReadPolicy = z.enum(["allow", "ask", "block"]);
+export type GoogleDriveReadPolicy = z.infer<typeof GoogleDriveReadPolicy>;
+
+export const GoogleDriveSelectedSource = z.object({
+  id: z.string().min(1).max(256),
+  name: z.string().min(1).max(1024),
+  mimeType: z.string().min(1).max(256),
+  driveId: z.string().min(1).max(256).nullable().default(null),
+  targetScope: GoogleDriveTargetScope,
+  syncCadence: GoogleDriveSyncCadence.default("hourly"),
+  readPolicy: GoogleDriveReadPolicy.default("allow"),
+  selectedAt: z.string().datetime({ offset: true }),
+});
+export type GoogleDriveSelectedSource = z.infer<typeof GoogleDriveSelectedSource>;
+
+export const GoogleDriveConnectionMetadata = z
+  .object({
+    credentialRole: z.literal(GOOGLE_DRIVE_CREDENTIAL_ROLE),
+    credentialLabel: z.literal(GOOGLE_DRIVE_CREDENTIAL_LABEL),
+    googlePermissionId: z.string().min(1).max(256),
+    googleEmail: z.string().email().max(320),
+    googleDisplayName: z.string().min(1).max(512).nullable(),
+    verifiedAt: z.string().datetime({ offset: true }),
+    accessMode: z.enum(["metadata_readonly", "readonly"]),
+    selectedSources: z.array(GoogleDriveSelectedSource).max(100).optional(),
+    /** @deprecated Read `selectedSources`; retained while existing connections migrate. */
+    selectedSource: GoogleDriveSelectedSource.nullable().optional(),
+  })
+  .passthrough();
+export type GoogleDriveConnectionMetadata = z.infer<typeof GoogleDriveConnectionMetadata>;
+
+export const GoogleDriveOAuthStartRequest = z.object({
+  connectionId: z.string().uuid().optional(),
+});
+export type GoogleDriveOAuthStartRequest = z.infer<typeof GoogleDriveOAuthStartRequest>;
+
+export const GoogleDriveOAuthStartResponse = z.object({
+  authorizationUrl: z.string().url(),
+  expiresAt: z.string().datetime({ offset: true }),
+});
+export type GoogleDriveOAuthStartResponse = z.infer<typeof GoogleDriveOAuthStartResponse>;
+
+export const GoogleDriveBrowseItem = z.object({
+  id: z.string().min(1).max(256),
+  name: z.string().min(1).max(1024),
+  mimeType: z.string().min(1).max(256),
+  kind: z.enum(["folder", "file"]),
+  driveId: z.string().min(1).max(256).nullable(),
+  modifiedTime: z.string().datetime({ offset: true }).nullable(),
+  size: z.string().regex(/^\d+$/).nullable(),
+  webViewLink: z.string().url().nullable(),
+});
+export type GoogleDriveBrowseItem = z.infer<typeof GoogleDriveBrowseItem>;
+
+export const GoogleDriveBrowseResponse = z.object({
+  connection: z.lazy(() => ConnectionMetadata),
+  parentId: z.string().min(1).max(256),
+  current: GoogleDriveBrowseItem.nullable(),
+  items: z.array(GoogleDriveBrowseItem),
+  nextPageToken: z.string().min(1).max(4096).nullable(),
+  incompleteSearch: z.boolean(),
+});
+export type GoogleDriveBrowseResponse = z.infer<typeof GoogleDriveBrowseResponse>;
+
+export const SaveGoogleDriveSourceRequest = z.object({
+  sources: z
+    .array(
+      GoogleDriveBrowseItem.pick({
+        id: true,
+        name: true,
+        mimeType: true,
+        driveId: true,
+      }),
+    )
+    .max(100)
+    .refine((sources) => new Set(sources.map((source) => source.id)).size === sources.length, {
+      message: "Google Drive sources must be unique",
+    }),
+  targetScope: GoogleDriveTargetScope,
+  syncCadence: GoogleDriveSyncCadence.default("hourly"),
+  readPolicy: GoogleDriveReadPolicy.default("allow"),
+});
+export type SaveGoogleDriveSourceRequest = z.infer<typeof SaveGoogleDriveSourceRequest>;