@synap-core/types 0.1.0

package/.turbo/turbo-build.log

@@ -0,0 +1,30 @@
+
+
+> @synap-core/types@0.1.0 build /Users/antoine/Documents/Code/synap/synap-backend/packages/types
+> tsup
+
+CLI Building entry: {"index":"src/index.ts","entities/index":"src/entities/index.ts","documents/index":"src/documents/index.ts","users/index":"src/users/index.ts","inbox/index":"src/inbox/index.ts"}
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /Users/antoine/Documents/Code/synap/synap-backend/packages/types/tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+ESM Build start
+ESM dist/index.js               3.57 KB
+ESM dist/users/index.js         33.00 B
+ESM dist/entities/index.js      2.40 KB
+ESM dist/inbox/index.js         1.18 KB
+ESM dist/documents/index.js     33.00 B
+ESM dist/entities/index.js.map  6.12 KB
+ESM dist/inbox/index.js.map     3.91 KB
+ESM dist/users/index.js.map     71.00 B
+ESM dist/index.js.map           9.99 KB
+ESM dist/documents/index.js.map 71.00 B
+ESM ⚡️ Build success in 15ms
+DTS Build start
+DTS ⚡️ Build success in 1457ms
+DTS dist/index.d.ts           687.00 B
+DTS dist/documents/index.d.ts 1.49 KB
+DTS dist/users/index.d.ts     1.55 KB
+DTS dist/inbox/index.d.ts     4.45 KB
+DTS dist/entities/index.d.ts  10.23 KB

package/dist/documents/index.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Document Types
+ *
+ * Types for document storage and versioning.
+ */
+/**
+ * Document - stores file content with versioning
+ */
+interface Document {
+    id: string;
+    userId: string;
+    title: string;
+    type: 'text' | 'markdown' | 'code' | 'pdf' | 'docx';
+    language?: string;
+    storageUrl: string;
+    storageKey: string;
+    size: number;
+    mimeType?: string;
+    currentVersion: number;
+    projectId?: string;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt?: Date;
+}
+/**
+ * Document version - stores historical versions
+ */
+interface DocumentVersion {
+    id: string;
+    documentId: string;
+    version: number;
+    content: string;
+    delta?: unknown;
+    author: '​user' | 'ai';
+    authorId: string;
+    message?: string;
+    createdAt: Date;
+}
+/**
+ * Document session - for real-time collaboration
+ */
+interface DocumentSession {
+    id: string;
+    documentId: string;
+    userId: string;
+    chatThreadId: string;
+    isActive: boolean;
+    activeCollaborators?: Array<{
+        type: 'user' | 'ai';
+        id: string;
+        cursor?: unknown;
+    }>;
+    startedAt: Date;
+    endedAt?: Date;
+}
+/**
+ * New document (for creation)
+ */
+type NewDocument = Omit<Document, 'id' | 'currentVersion' | 'createdAt' | 'updatedAt'>;
+/**
+ * Document update (for updates)
+ */
+type UpdateDocument = Partial<Omit<Document, 'id' | 'userId' | 'createdAt' | 'updatedAt'>>;
+
+export type { Document, DocumentSession, DocumentVersion, NewDocument, UpdateDocument };

package/dist/documents/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=index.js.map

package/dist/documents/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/entities/index.d.ts

@@ -0,0 +1,327 @@
+import { z } from 'zod';
+
+/**
+ * Entity Metadata Schemas
+ *
+ * Defines Zod schemas for all entity types.
+ * TypeScript types are auto-generated from these schemas.
+ *
+ * Adding a new entity type: Just add to ENTITY_SCHEMAS!
+ */
+
+/**
+ * Entity metadata schemas - one per entity type
+ *
+ * The type key MUST match the entity.type field in the database
+ */
+declare const ENTITY_SCHEMAS: {
+    readonly task: z.ZodObject<{
+        status: z.ZodDefault<z.ZodEnum<["todo", "in_progress", "done", "archived"]>>;
+        priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "urgent"]>>;
+        dueDate: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+        assignee: z.ZodOptional<z.ZodString>;
+        estimatedMinutes: z.ZodOptional<z.ZodNumber>;
+        actualMinutes: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        status: "todo" | "in_progress" | "done" | "archived";
+        priority?: "low" | "medium" | "high" | "urgent" | undefined;
+        dueDate?: string | undefined;
+        completedAt?: string | undefined;
+        assignee?: string | undefined;
+        estimatedMinutes?: number | undefined;
+        actualMinutes?: number | undefined;
+    }, {
+        status?: "todo" | "in_progress" | "done" | "archived" | undefined;
+        priority?: "low" | "medium" | "high" | "urgent" | undefined;
+        dueDate?: string | undefined;
+        completedAt?: string | undefined;
+        assignee?: string | undefined;
+        estimatedMinutes?: number | undefined;
+        actualMinutes?: number | undefined;
+    }>;
+    readonly note: z.ZodObject<{
+        tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        format: z.ZodDefault<z.ZodEnum<["markdown", "plain", "rich"]>>;
+        linkedEntities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        isFavorite: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        tags: string[];
+        format: "markdown" | "plain" | "rich";
+        isFavorite: boolean;
+        linkedEntities?: string[] | undefined;
+    }, {
+        tags?: string[] | undefined;
+        format?: "markdown" | "plain" | "rich" | undefined;
+        linkedEntities?: string[] | undefined;
+        isFavorite?: boolean | undefined;
+    }>;
+    readonly person: z.ZodObject<{
+        email: z.ZodOptional<z.ZodString>;
+        phone: z.ZodOptional<z.ZodString>;
+        company: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
+        linkedInUrl: z.ZodOptional<z.ZodString>;
+        twitterHandle: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        email?: string | undefined;
+        phone?: string | undefined;
+        company?: string | undefined;
+        role?: string | undefined;
+        linkedInUrl?: string | undefined;
+        twitterHandle?: string | undefined;
+        notes?: string | undefined;
+    }, {
+        email?: string | undefined;
+        phone?: string | undefined;
+        company?: string | undefined;
+        role?: string | undefined;
+        linkedInUrl?: string | undefined;
+        twitterHandle?: string | undefined;
+        notes?: string | undefined;
+    }>;
+    readonly event: z.ZodObject<{
+        startTime: z.ZodString;
+        endTime: z.ZodString;
+        location: z.ZodOptional<z.ZodString>;
+        attendees: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        recurring: z.ZodDefault<z.ZodBoolean>;
+        recurrenceRule: z.ZodOptional<z.ZodString>;
+        isAllDay: z.ZodDefault<z.ZodBoolean>;
+        reminderMinutes: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        startTime: string;
+        endTime: string;
+        recurring: boolean;
+        isAllDay: boolean;
+        location?: string | undefined;
+        attendees?: string[] | undefined;
+        recurrenceRule?: string | undefined;
+        reminderMinutes?: number | undefined;
+    }, {
+        startTime: string;
+        endTime: string;
+        location?: string | undefined;
+        attendees?: string[] | undefined;
+        recurring?: boolean | undefined;
+        recurrenceRule?: string | undefined;
+        isAllDay?: boolean | undefined;
+        reminderMinutes?: number | undefined;
+    }>;
+    readonly file: z.ZodObject<{
+        mimeType: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        extension: z.ZodString;
+        thumbnailUrl: z.ZodOptional<z.ZodString>;
+        downloadUrl: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        mimeType: string;
+        sizeBytes: number;
+        extension: string;
+        thumbnailUrl?: string | undefined;
+        downloadUrl?: string | undefined;
+    }, {
+        mimeType: string;
+        sizeBytes: number;
+        extension: string;
+        thumbnailUrl?: string | undefined;
+        downloadUrl?: string | undefined;
+    }>;
+};
+/**
+ * Entity type enum - auto-generated from schema keys
+ */
+type EntityType = keyof typeof ENTITY_SCHEMAS;
+/**
+ * Entity metadata types - auto-generated from schemas
+ */
+type EntityMetadata = {
+    [K in EntityType]: z.infer<typeof ENTITY_SCHEMAS[K]>;
+};
+/**
+ * Validation helper - validates metadata for a specific entity type
+ * Returns parsed metadata with proper typing
+ */
+declare function validateEntityMetadata<T extends EntityType>(type: T, metadata: unknown): z.infer<typeof ENTITY_SCHEMAS[T]>;
+/**
+ * Safe validation helper - returns result with success/error
+ */
+declare function safeValidateEntityMetadata<T extends EntityType>(type: T, metadata: unknown): z.SafeParseReturnType<{
+    status?: "todo" | "in_progress" | "done" | "archived" | undefined;
+    priority?: "low" | "medium" | "high" | "urgent" | undefined;
+    dueDate?: string | undefined;
+    completedAt?: string | undefined;
+    assignee?: string | undefined;
+    estimatedMinutes?: number | undefined;
+    actualMinutes?: number | undefined;
+}, {
+    status: "todo" | "in_progress" | "done" | "archived";
+    priority?: "low" | "medium" | "high" | "urgent" | undefined;
+    dueDate?: string | undefined;
+    completedAt?: string | undefined;
+    assignee?: string | undefined;
+    estimatedMinutes?: number | undefined;
+    actualMinutes?: number | undefined;
+}> | z.SafeParseReturnType<{
+    tags?: string[] | undefined;
+    format?: "markdown" | "plain" | "rich" | undefined;
+    linkedEntities?: string[] | undefined;
+    isFavorite?: boolean | undefined;
+}, {
+    tags: string[];
+    format: "markdown" | "plain" | "rich";
+    isFavorite: boolean;
+    linkedEntities?: string[] | undefined;
+}> | z.SafeParseReturnType<{
+    email?: string | undefined;
+    phone?: string | undefined;
+    company?: string | undefined;
+    role?: string | undefined;
+    linkedInUrl?: string | undefined;
+    twitterHandle?: string | undefined;
+    notes?: string | undefined;
+}, {
+    email?: string | undefined;
+    phone?: string | undefined;
+    company?: string | undefined;
+    role?: string | undefined;
+    linkedInUrl?: string | undefined;
+    twitterHandle?: string | undefined;
+    notes?: string | undefined;
+}> | z.SafeParseReturnType<{
+    startTime: string;
+    endTime: string;
+    location?: string | undefined;
+    attendees?: string[] | undefined;
+    recurring?: boolean | undefined;
+    recurrenceRule?: string | undefined;
+    isAllDay?: boolean | undefined;
+    reminderMinutes?: number | undefined;
+}, {
+    startTime: string;
+    endTime: string;
+    recurring: boolean;
+    isAllDay: boolean;
+    location?: string | undefined;
+    attendees?: string[] | undefined;
+    recurrenceRule?: string | undefined;
+    reminderMinutes?: number | undefined;
+}> | z.SafeParseReturnType<{
+    mimeType: string;
+    sizeBytes: number;
+    extension: string;
+    thumbnailUrl?: string | undefined;
+    downloadUrl?: string | undefined;
+}, {
+    mimeType: string;
+    sizeBytes: number;
+    extension: string;
+    thumbnailUrl?: string | undefined;
+    downloadUrl?: string | undefined;
+}>;
+
+/**
+ * Entity Types
+ *
+ * TypeScript types for entities with discriminated unions.
+ * Types are automatically generated from Zod schemas.
+ */
+
+/**
+ * Base entity - common fields for all entity types
+ */
+interface BaseEntity {
+    id: string;
+    userId: string;
+    type: EntityType;
+    title?: string;
+    preview?: string;
+    documentId?: string;
+    version: number;
+    createdAt: Date;
+    updatedAt: Date;
+    deletedAt?: Date;
+}
+/**
+ * Entity - Discriminated union of all entity types
+ *
+ * TypeScript automatically narrows the type based on the `type` field:
+ *
+ * ```ts
+ * if (entity.type === 'task') {
+ *   // entity.metadata.status is accessible and type-safe!
+ * }
+ * ```
+ */
+type Entity = {
+    [K in EntityType]: BaseEntity & {
+        type: K;
+        metadata: EntityMetadata[K];
+    };
+}[EntityType];
+/**
+ * Specific entity types (for explicit typing)
+ */
+type Task = Extract<Entity, {
+    type: 'task';
+}>;
+type Note = Extract<Entity, {
+    type: 'note';
+}>;
+type Person = Extract<Entity, {
+    type: 'person';
+}>;
+type Event = Extract<Entity, {
+    type: 'event';
+}>;
+type File = Extract<Entity, {
+    type: 'file';
+}>;
+/**
+ * New entity type (for creation)
+ */
+type NewEntity<T extends EntityType = EntityType> = Omit<Extract<Entity, {
+    type: T;
+}>, 'id' | 'version' | 'createdAt' | 'updatedAt'>;
+/**
+ * Entity update type (for updates)
+ */
+type UpdateEntity<T extends EntityType = EntityType> = Partial<Omit<Extract<Entity, {
+    type: T;
+}>, 'id' | 'userId' | 'type' | 'createdAt' | 'updatedAt'>>;
+
+/**
+ * Entity Type Guards
+ *
+ * Type guard functions for narrowing entity types.
+ */
+
+/**
+ * Type guard for Task entities
+ */
+declare function isTask(entity: Entity): entity is Task;
+/**
+ * Type guard for Note entities
+ */
+declare function isNote(entity: Entity): entity is Note;
+/**
+ * Type guard for Person entities
+ */
+declare function isPerson(entity: Entity): entity is Person;
+/**
+ * Type guard for Event entities
+ */
+declare function isEvent(entity: Entity): entity is Event;
+/**
+ * Type guard for File entities
+ */
+declare function isFile(entity: Entity): entity is File;
+/**
+ * Generic type guard for any entity type
+ */
+declare function isEntityOfType<T extends Entity['type']>(entity: Entity, type: T): entity is Extract<Entity, {
+    type: T;
+}>;
+
+export { type BaseEntity, ENTITY_SCHEMAS, type Entity, type EntityMetadata, type EntityType, type Event, type File, type NewEntity, type Note, type Person, type Task, type UpdateEntity, isEntityOfType, isEvent, isFile, isNote, isPerson, isTask, safeValidateEntityMetadata, validateEntityMetadata };

package/dist/entities/index.js

@@ -0,0 +1,84 @@
+// src/entities/schemas.ts
+import { z } from "zod";
+var ENTITY_SCHEMAS = {
+  task: z.object({
+    status: z.enum(["todo", "in_progress", "done", "archived"]).default("todo"),
+    priority: z.enum(["low", "medium", "high", "urgent"]).optional(),
+    dueDate: z.string().datetime().optional(),
+    completedAt: z.string().datetime().optional(),
+    assignee: z.string().uuid().optional(),
+    estimatedMinutes: z.number().int().positive().optional(),
+    actualMinutes: z.number().int().positive().optional()
+  }),
+  note: z.object({
+    tags: z.array(z.string()).default([]),
+    format: z.enum(["markdown", "plain", "rich"]).default("markdown"),
+    linkedEntities: z.array(z.string().uuid()).optional(),
+    isFavorite: z.boolean().default(false)
+  }),
+  person: z.object({
+    email: z.string().email().optional(),
+    phone: z.string().optional(),
+    company: z.string().optional(),
+    role: z.string().optional(),
+    linkedInUrl: z.string().url().optional(),
+    twitterHandle: z.string().optional(),
+    notes: z.string().optional()
+  }),
+  event: z.object({
+    startTime: z.string().datetime(),
+    endTime: z.string().datetime(),
+    location: z.string().optional(),
+    attendees: z.array(z.string().uuid()).optional(),
+    recurring: z.boolean().default(false),
+    recurrenceRule: z.string().optional(),
+    // iCal RRULE format
+    isAllDay: z.boolean().default(false),
+    reminderMinutes: z.number().int().optional()
+  }),
+  file: z.object({
+    mimeType: z.string(),
+    sizeBytes: z.number().int().positive(),
+    extension: z.string(),
+    thumbnailUrl: z.string().url().optional(),
+    downloadUrl: z.string().url().optional()
+  })
+};
+function validateEntityMetadata(type, metadata) {
+  return ENTITY_SCHEMAS[type].parse(metadata);
+}
+function safeValidateEntityMetadata(type, metadata) {
+  return ENTITY_SCHEMAS[type].safeParse(metadata);
+}
+
+// src/entities/guards.ts
+function isTask(entity) {
+  return entity.type === "task";
+}
+function isNote(entity) {
+  return entity.type === "note";
+}
+function isPerson(entity) {
+  return entity.type === "person";
+}
+function isEvent(entity) {
+  return entity.type === "event";
+}
+function isFile(entity) {
+  return entity.type === "file";
+}
+function isEntityOfType(entity, type) {
+  return entity.type === type;
+}
+export {
+  ENTITY_SCHEMAS,
+  isEntityOfType,
+  isEvent,
+  isFile,
+  isNote,
+  isPerson,
+  isTask,
+  safeValidateEntityMetadata,
+  validateEntityMetadata
+};
+//# sourceMappingURL=index.js.map

package/dist/entities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/entities/schemas.ts","../../src/entities/guards.ts"],"sourcesContent":["/**\n * Entity Metadata Schemas\n * \n * Defines Zod schemas for all entity types.\n * TypeScript types are auto-generated from these schemas.\n * \n * Adding a new entity type: Just add to ENTITY_SCHEMAS!\n */\n\nimport { z } from 'zod';\n\n/**\n * Entity metadata schemas - one per entity type\n * \n * The type key MUST match the entity.type field in the database\n */\nexport const ENTITY_SCHEMAS = {\n  task: z.object({\n    status: z.enum(['todo', 'in_progress', 'done', 'archived']).default('todo'),\n    priority: z.enum(['low', 'medium', 'high', 'urgent']).optional(),\n    dueDate: z.string().datetime().optional(),\n    completedAt: z.string().datetime().optional(),\n    assignee: z.string().uuid().optional(),\n    estimatedMinutes: z.number().int().positive().optional(),\n    actualMinutes: z.number().int().positive().optional(),\n  }),\n  \n  note: z.object({\n    tags: z.array(z.string()).default([]),\n    format: z.enum(['markdown', 'plain', 'rich']).default('markdown'),\n    linkedEntities: z.array(z.string().uuid()).optional(),\n    isFavorite: z.boolean().default(false),\n  }),\n  \n  person: z.object({\n    email: z.string().email().optional(),\n    phone: z.string().optional(),\n    company: z.string().optional(),\n    role: z.string().optional(),\n    linkedInUrl: z.string().url().optional(),\n    twitterHandle: z.string().optional(),\n    notes: z.string().optional(),\n  }),\n  \n  event: z.object({\n    startTime: z.string().datetime(),\n    endTime: z.string().datetime(),\n    location: z.string().optional(),\n    attendees: z.array(z.string().uuid()).optional(),\n    recurring: z.boolean().default(false),\n    recurrenceRule: z.string().optional(), // iCal RRULE format\n    isAllDay: z.boolean().default(false),\n    reminderMinutes: z.number().int().optional(),\n  }),\n  \n  file: z.object({\n    mimeType: z.string(),\n    sizeBytes: z.number().int().positive(),\n    extension: z.string(),\n    thumbnailUrl: z.string().url().optional(),\n    downloadUrl: z.string().url().optional(),\n  }),\n} as const;\n\n/**\n * Entity type enum - auto-generated from schema keys\n */\nexport type EntityType = keyof typeof ENTITY_SCHEMAS;\n\n/**\n * Entity metadata types - auto-generated from schemas\n */\nexport type EntityMetadata = {\n  [K in EntityType]: z.infer<typeof ENTITY_SCHEMAS[K]>\n};\n\n/**\n * Validation helper - validates metadata for a specific entity type\n * Returns parsed metadata with proper typing\n */\nexport function validateEntityMetadata<T extends EntityType>(\n  type: T,\n  metadata: unknown\n): z.infer<typeof ENTITY_SCHEMAS[T]> {\n  return ENTITY_SCHEMAS[type].parse(metadata) as z.infer<typeof ENTITY_SCHEMAS[T]>;\n}\n\n/**\n * Safe validation helper - returns result with success/error\n */\nexport function safeValidateEntityMetadata<T extends EntityType>(\n  type: T,\n  metadata: unknown\n) {\n  return ENTITY_SCHEMAS[type].safeParse(metadata);\n}\n","/**\n * Entity Type Guards\n * \n * Type guard functions for narrowing entity types.\n */\n\nimport type { Entity, Task, Note, Person, Event, File } from './types.js';\n\n/**\n * Type guard for Task entities\n */\nexport function isTask(entity: Entity): entity is Task {\n  return entity.type === 'task';\n}\n\n/**\n * Type guard for Note entities\n */\nexport function isNote(entity: Entity): entity is Note {\n  return entity.type === 'note';\n}\n\n/**\n * Type guard for Person entities\n */\nexport function isPerson(entity: Entity): entity is Person {\n  return entity.type === 'person';\n}\n\n/**\n * Type guard for Event entities\n */\nexport function isEvent(entity: Entity): entity is Event {\n  return entity.type === 'event';\n}\n\n/**\n * Type guard for File entities\n */\nexport function isFile(entity: Entity): entity is File {\n  return entity.type === 'file';\n}\n\n/**\n * Generic type guard for any entity type\n */\nexport function isEntityOfType<T extends Entity['type']>(\n  entity: Entity,\n  type: T\n): entity is Extract<Entity, { type: T }> {\n  return entity.type === type;\n}\n"],"mappings":"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","names":[]}

package/dist/inbox/index.d.ts

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+
+/**
+ * Inbox Item Schemas & Types
+ *
+ * Types for external items (emails, calendar events, etc.)
+ * that are staged in the inbox before becoming entities.
+ */
+
+/**
+ * Inbox item data schemas - provider-specific
+ */
+declare const INBOX_SCHEMAS: {
+    readonly email: z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodArray<z.ZodString, "many">;
+        subject: z.ZodString;
+        snippet: z.ZodString;
+        threadId: z.ZodOptional<z.ZodString>;
+        labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string[];
+        subject: string;
+        snippet: string;
+        threadId?: string | undefined;
+        labels?: string[] | undefined;
+    }, {
+        from: string;
+        to: string[];
+        subject: string;
+        snippet: string;
+        threadId?: string | undefined;
+        labels?: string[] | undefined;
+    }>;
+    readonly calendar_event: z.ZodObject<{
+        summary: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        location: z.ZodOptional<z.ZodString>;
+        start: z.ZodString;
+        end: z.ZodString;
+        attendees: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            email: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            email: string;
+            name?: string | undefined;
+        }, {
+            email: string;
+            name?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        summary: string;
+        start: string;
+        end: string;
+        location?: string | undefined;
+        attendees?: {
+            email: string;
+            name?: string | undefined;
+        }[] | undefined;
+        description?: string | undefined;
+    }, {
+        summary: string;
+        start: string;
+        end: string;
+        location?: string | undefined;
+        attendees?: {
+            email: string;
+            name?: string | undefined;
+        }[] | undefined;
+        description?: string | undefined;
+    }>;
+    readonly slack_message: z.ZodObject<{
+        channel: z.ZodString;
+        user: z.ZodString;
+        text: z.ZodString;
+        threadTs: z.ZodOptional<z.ZodString>;
+        reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            count: number;
+        }, {
+            name: string;
+            count: number;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        text: string;
+        user: string;
+        channel: string;
+        threadTs?: string | undefined;
+        reactions?: {
+            name: string;
+            count: number;
+        }[] | undefined;
+    }, {
+        text: string;
+        user: string;
+        channel: string;
+        threadTs?: string | undefined;
+        reactions?: {
+            name: string;
+            count: number;
+        }[] | undefined;
+    }>;
+};
+type InboxItemType = keyof typeof INBOX_SCHEMAS;
+type InboxItemData = {
+    [K in InboxItemType]: z.infer<typeof INBOX_SCHEMAS[K]>;
+};
+/**
+ * Base inbox item fields
+ */
+interface BaseInboxItem {
+    id: string;
+    userId: string;
+    provider: 'gmail' | 'google_calendar' | 'slack';
+    account: string;
+    externalId: string;
+    deepLink?: string;
+    type: InboxItemType;
+    title: string;
+    preview?: string;
+    timestamp: Date;
+    status: 'unread' | 'read' | 'archived' | 'snoozed';
+    snoozedUntil?: Date;
+    priority?: 'urgent' | 'high' | 'normal' | 'low';
+    tags: string[];
+    processedAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Inbox item - discriminated union
+ */
+type InboxItem = {
+    [K in InboxItemType]: BaseInboxItem & {
+        type: K;
+        data: InboxItemData[K];
+    };
+}[InboxItemType];
+/**
+ * Specific inbox item types
+ */
+type EmailInboxItem = Extract<InboxItem, {
+    type: 'email';
+}>;
+type CalendarInboxItem = Extract<InboxItem, {
+    type: 'calendar_event';
+}>;
+type SlackInboxItem = Extract<InboxItem, {
+    type: 'slack_message';
+}>;
+/**
+ * Type guards
+ */
+declare function isEmailInboxItem(item: InboxItem): item is EmailInboxItem;
+declare function isCalendarInboxItem(item: InboxItem): item is CalendarInboxItem;
+declare function isSlackInboxItem(item: InboxItem): item is SlackInboxItem;
+
+export { type CalendarInboxItem, type EmailInboxItem, INBOX_SCHEMAS, type InboxItem, type InboxItemType, type SlackInboxItem, isCalendarInboxItem, isEmailInboxItem, isSlackInboxItem };