@guidemode/types 0.1.43

package/dist/esm/providers/gemini/entries.d.ts

@@ -0,0 +1,319 @@
+/**
+ * Gemini provider type definitions
+ * Gemini extends Claude's message format with additional thinking and token tracking
+ */
+import { z } from 'zod';
+/**
+ * Gemini thought structure (extended thinking)
+ */
+export declare const ThoughtSchema: z.ZodObject<{
+    subject: z.ZodString;
+    description: z.ZodString;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    subject: string;
+    description: string;
+}, {
+    timestamp: string;
+    subject: string;
+    description: string;
+}>;
+export type Thought = z.infer<typeof ThoughtSchema>;
+/**
+ * Gemini token metrics
+ * Provides granular breakdown of token usage
+ */
+export declare const TokenMetricsSchema: z.ZodObject<{
+    input: z.ZodNumber;
+    output: z.ZodNumber;
+    cached: z.ZodOptional<z.ZodNumber>;
+    thoughts: z.ZodOptional<z.ZodNumber>;
+    tool: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    input: number;
+    output: number;
+    total: number;
+    cached?: number | undefined;
+    thoughts?: number | undefined;
+    tool?: number | undefined;
+}, {
+    input: number;
+    output: number;
+    total: number;
+    cached?: number | undefined;
+    thoughts?: number | undefined;
+    tool?: number | undefined;
+}>;
+export type TokenMetrics = z.infer<typeof TokenMetricsSchema>;
+/**
+ * Gemini message entry (extends Claude format)
+ */
+export declare const GeminiMessageSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodEnum<["user", "assistant", "summary", "system"]>;
+    message: z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: "text";
+            text: string;
+        }, {
+            type: "text";
+            text: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_use">;
+            id: z.ZodString;
+            name: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        }, {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_result">;
+            tool_use_id: z.ZodString;
+            content: z.ZodUnknown;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "tool_result";
+            tool_use_id: string;
+            content?: unknown;
+            is_error?: boolean | undefined;
+        }, {
+            type: "tool_result";
+            tool_use_id: string;
+            content?: unknown;
+            is_error?: boolean | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"thinking">;
+            thinking: z.ZodOptional<z.ZodString>;
+            signature: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: "thinking";
+            thinking?: string | undefined;
+            signature?: string | undefined;
+        }, {
+            type: "thinking";
+            thinking?: string | undefined;
+            signature?: string | undefined;
+        }>, z.ZodObject<{
+            type: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>]>, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content?: unknown;
+            is_error?: boolean | undefined;
+        } | {
+            type: "thinking";
+            thinking?: string | undefined;
+            signature?: string | undefined;
+        } | z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">)[];
+        role: string;
+    }, {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content?: unknown;
+            is_error?: boolean | undefined;
+        } | {
+            type: "thinking";
+            thinking?: string | undefined;
+            signature?: string | undefined;
+        } | z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">)[];
+        role: string;
+    }>;
+    thoughts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        subject: z.ZodString;
+        description: z.ZodString;
+        timestamp: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        subject: string;
+        description: string;
+    }, {
+        timestamp: string;
+        subject: string;
+        description: string;
+    }>, "many">>;
+    tokens: z.ZodOptional<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cached: z.ZodOptional<z.ZodNumber>;
+        thoughts: z.ZodOptional<z.ZodNumber>;
+        tool: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        input: number;
+        output: number;
+        total: number;
+        cached?: number | undefined;
+        thoughts?: number | undefined;
+        tool?: number | undefined;
+    }, {
+        input: number;
+        output: number;
+        total: number;
+        cached?: number | undefined;
+        thoughts?: number | undefined;
+        tool?: number | undefined;
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+    parentUuid: z.ZodOptional<z.ZodString>;
+    isMeta: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    message: {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content?: unknown;
+            is_error?: boolean | undefined;
+        } | {
+            type: "thinking";
+            thinking?: string | undefined;
+            signature?: string | undefined;
+        } | z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">)[];
+        role: string;
+    };
+    type: "user" | "assistant" | "summary" | "system";
+    uuid: string;
+    timestamp: string;
+    sessionId: string;
+    model?: string | undefined;
+    parentUuid?: string | undefined;
+    isMeta?: boolean | undefined;
+    thoughts?: {
+        timestamp: string;
+        subject: string;
+        description: string;
+    }[] | undefined;
+    tokens?: {
+        input: number;
+        output: number;
+        total: number;
+        cached?: number | undefined;
+        thoughts?: number | undefined;
+        tool?: number | undefined;
+    } | undefined;
+}, {
+    message: {
+        content: string | ({
+            type: "text";
+            text: string;
+        } | {
+            type: "tool_use";
+            id: string;
+            name: string;
+            input: Record<string, unknown>;
+        } | {
+            type: "tool_result";
+            tool_use_id: string;
+            content?: unknown;
+            is_error?: boolean | undefined;
+        } | {
+            type: "thinking";
+            thinking?: string | undefined;
+            signature?: string | undefined;
+        } | z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">)[];
+        role: string;
+    };
+    type: "user" | "assistant" | "summary" | "system";
+    uuid: string;
+    timestamp: string;
+    sessionId: string;
+    model?: string | undefined;
+    parentUuid?: string | undefined;
+    isMeta?: boolean | undefined;
+    thoughts?: {
+        timestamp: string;
+        subject: string;
+        description: string;
+    }[] | undefined;
+    tokens?: {
+        input: number;
+        output: number;
+        total: number;
+        cached?: number | undefined;
+        thoughts?: number | undefined;
+        tool?: number | undefined;
+    } | undefined;
+}>;
+export type GeminiMessage = z.infer<typeof GeminiMessageSchema>;
+/**
+ * Gemini metadata extension for ParsedMessage
+ */
+export interface GeminiMetadata {
+    thoughts?: Thought[];
+    thoughtCount?: number;
+    hasThoughts: boolean;
+    tokens?: TokenMetrics;
+    hasCachedTokens: boolean;
+    hasThinkingTokens: boolean;
+    cacheHitRate?: number;
+    thinkingOverhead?: number;
+    model?: string;
+}
+/**
+ * Type guards
+ */
+export declare function isGeminiMessage(entry: unknown): entry is GeminiMessage;
+export declare function hasGeminiThoughts(message: GeminiMessage): boolean;
+export declare function hasGeminiTokens(message: GeminiMessage): boolean;
+/**
+ * Helper to calculate cache hit rate
+ */
+export declare function calculateCacheHitRate(tokens: TokenMetrics): number;
+/**
+ * Helper to calculate thinking overhead
+ */
+export declare function calculateThinkingOverhead(tokens: TokenMetrics): number;
+//# sourceMappingURL=entries.d.ts.map

package/dist/esm/providers/gemini/entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../../../src/providers/gemini/entries.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;EAIxB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEnD;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAO7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAuC7D;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkB9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,eAAe,EAAE,OAAO,CAAA;IACxB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAGtE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAEjE;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAE/D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAGlE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAGtE"}

package/dist/esm/providers/gemini/entries.js

@@ -0,0 +1,111 @@
+/**
+ * Gemini provider type definitions
+ * Gemini extends Claude's message format with additional thinking and token tracking
+ */
+import { z } from 'zod';
+/**
+ * Gemini thought structure (extended thinking)
+ */
+export const ThoughtSchema = z.object({
+    subject: z.string(),
+    description: z.string(),
+    timestamp: z.string(),
+});
+/**
+ * Gemini token metrics
+ * Provides granular breakdown of token usage
+ */
+export const TokenMetricsSchema = z.object({
+    input: z.number(),
+    output: z.number(),
+    cached: z.number().optional(),
+    thoughts: z.number().optional(), // Thinking token overhead
+    tool: z.number().optional(),
+    total: z.number(),
+});
+/**
+ * Content block schema (reuses shared types at runtime)
+ */
+const ContentBlockSchema = z.union([
+    // Text
+    z.object({
+        type: z.literal('text'),
+        text: z.string(),
+    }),
+    // Tool use
+    z.object({
+        type: z.literal('tool_use'),
+        id: z.string(),
+        name: z.string(),
+        input: z.record(z.unknown()),
+    }),
+    // Tool result
+    z.object({
+        type: z.literal('tool_result'),
+        tool_use_id: z.string(),
+        content: z.unknown(),
+        is_error: z.boolean().optional(),
+    }),
+    // Thinking
+    z.object({
+        type: z.literal('thinking'),
+        thinking: z.string().optional(),
+        signature: z.string().optional(),
+    }),
+    // Unknown (catch-all)
+    z
+        .object({
+        type: z.string(),
+    })
+        .passthrough(),
+]);
+/**
+ * Gemini message entry (extends Claude format)
+ */
+export const GeminiMessageSchema = z.object({
+    uuid: z.string(),
+    timestamp: z.string(),
+    type: z.enum(['user', 'assistant', 'summary', 'system']),
+    message: z.object({
+        role: z.string(),
+        content: z.union([z.string(), z.array(ContentBlockSchema)]),
+    }),
+    // Gemini-specific fields
+    thoughts: z.array(ThoughtSchema).optional(),
+    tokens: TokenMetricsSchema.optional(),
+    model: z.string().optional(),
+    // Standard fields
+    sessionId: z.string(),
+    parentUuid: z.string().optional(),
+    isMeta: z.boolean().optional(),
+});
+/**
+ * Type guards
+ */
+export function isGeminiMessage(entry) {
+    const result = GeminiMessageSchema.safeParse(entry);
+    return result.success;
+}
+export function hasGeminiThoughts(message) {
+    return !!message.thoughts && message.thoughts.length > 0;
+}
+export function hasGeminiTokens(message) {
+    return !!message.tokens;
+}
+/**
+ * Helper to calculate cache hit rate
+ */
+export function calculateCacheHitRate(tokens) {
+    if (!tokens.cached || tokens.total === 0)
+        return 0;
+    return (tokens.cached / tokens.total) * 100;
+}
+/**
+ * Helper to calculate thinking overhead
+ */
+export function calculateThinkingOverhead(tokens) {
+    if (!tokens.thoughts || tokens.output === 0)
+        return 0;
+    return tokens.thoughts / tokens.output;
+}
+//# sourceMappingURL=entries.js.map

package/dist/esm/providers/gemini/entries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.js","sourceRoot":"","sources":["../../../../src/providers/gemini/entries.ts"],"names":[],"mappings":"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"}

package/dist/esm/providers/gemini/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Gemini provider types and schemas
+ */
+export { ThoughtSchema, TokenMetricsSchema, GeminiMessageSchema, isGeminiMessage, hasGeminiThoughts, hasGeminiTokens, calculateCacheHitRate, calculateThinkingOverhead, } from './entries.js';
+export type { Thought, TokenMetrics, GeminiMessage, GeminiMetadata, } from './entries.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/providers/gemini/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/providers/gemini/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,OAAO,EACP,YAAY,EACZ,aAAa,EACb,cAAc,GACf,MAAM,cAAc,CAAA"}

package/dist/esm/providers/gemini/index.js

@@ -0,0 +1,5 @@
+/**
+ * Gemini provider types and schemas
+ */
+export { ThoughtSchema, TokenMetricsSchema, GeminiMessageSchema, isGeminiMessage, hasGeminiThoughts, hasGeminiTokens, calculateCacheHitRate, calculateThinkingOverhead, } from './entries.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/providers/gemini/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/providers/gemini/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,cAAc,CAAA"}

package/dist/esm/providers/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Provider-specific type schemas
+ *
+ * Each provider (Claude Code, Cursor, Windsurf, etc.) has its own
+ * JSONL entry format. This module provides Zod schemas and TypeScript
+ * types for runtime validation and type safety.
+ *
+ * @example
+ * ```typescript
+ * import { Claude } from '@guidemode/types/providers';
+ *
+ * // Parse JSONL entry
+ * const entry = Claude.AnyEntrySchema.parse(jsonData);
+ *
+ * // Type-safe access
+ * if (Claude.isUserEntry(entry)) {
+ *   console.log(entry.message.content);
+ * }
+ * ```
+ */
+export * as Claude from './claude/index.js';
+export * as Codex from './codex/index.js';
+export * as OpenCode from './opencode/index.js';
+export * as Gemini from './gemini/index.js';
+export * as Copilot from './copilot/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAA;AACzC,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAC/C,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA"}

package/dist/esm/providers/index.js

@@ -0,0 +1,29 @@
+/**
+ * Provider-specific type schemas
+ *
+ * Each provider (Claude Code, Cursor, Windsurf, etc.) has its own
+ * JSONL entry format. This module provides Zod schemas and TypeScript
+ * types for runtime validation and type safety.
+ *
+ * @example
+ * ```typescript
+ * import { Claude } from '@guidemode/types/providers';
+ *
+ * // Parse JSONL entry
+ * const entry = Claude.AnyEntrySchema.parse(jsonData);
+ *
+ * // Type-safe access
+ * if (Claude.isUserEntry(entry)) {
+ *   console.log(entry.message.content);
+ * }
+ * ```
+ */
+// Export provider namespaces as they are added
+export * as Claude from './claude/index.js';
+export * as Codex from './codex/index.js';
+export * as OpenCode from './opencode/index.js';
+export * as Gemini from './gemini/index.js';
+export * as Copilot from './copilot/index.js';
+// export * as Cursor from './cursor/index.js';
+// export * as Windsurf from './windsurf/index.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/providers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/providers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,+CAA+C;AAC/C,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAA;AACzC,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAC/C,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA;AAC7C,+CAA+C;AAC/C,mDAAmD"}

package/dist/esm/providers/opencode/entries.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Auto-generated Zod schemas for OpenCode JSONL entries
+ *
+ * Generated: 2025-10-16T03:22:32.267Z
+ * Source: provider-docs/opencode/opencode-jsonl.json
+ * Entry types: user
+ * Total files processed: 51
+ */
+import { z } from 'zod';
+/**
+ * User message entry from OpenCode session logs
+ *
+ * Required fields:
+ * - type: Always 'user'
+ * - sessionId: Session identifier
+ * - timestamp: ISO 8601 timestamp
+ * - cwd: Current working directory
+ * - message: User message object with role and content
+ */
+export declare const UserSchema: z.ZodObject<{
+    type: z.ZodLiteral<"user">;
+    sessionId: z.ZodString;
+    timestamp: z.ZodString;
+    cwd: z.ZodString;
+    message: z.ZodObject<{
+        role: z.ZodLiteral<"user">;
+        content: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            text?: string | undefined;
+        }, {
+            type: string;
+            text?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        content: {
+            type: string;
+            text?: string | undefined;
+        }[];
+        role: "user";
+    }, {
+        content: {
+            type: string;
+            text?: string | undefined;
+        }[];
+        role: "user";
+    }>;
+}, "strict", z.ZodTypeAny, {
+    message: {
+        content: {
+            type: string;
+            text?: string | undefined;
+        }[];
+        role: "user";
+    };
+    type: "user";
+    timestamp: string;
+    sessionId: string;
+    cwd: string;
+}, {
+    message: {
+        content: {
+            type: string;
+            text?: string | undefined;
+        }[];
+        role: "user";
+    };
+    type: "user";
+    timestamp: string;
+    sessionId: string;
+    cwd: string;
+}>;
+export type User = z.infer<typeof UserSchema>;
+/**
+ * Union of all known JSONL entry types.
+ * Use this when parsing entries of unknown type.
+ *
+ * Note: Currently only contains UserSchema as OpenCode only exports user entries.
+ */
+export declare const AnyEntrySchema: z.ZodObject<{
+    type: z.ZodLiteral<"user">;
+    sessionId: z.ZodString;
+    timestamp: z.ZodString;
+    cwd: z.ZodString;
+    message: z.ZodObject<{
+        role: z.ZodLiteral<"user">;
+        content: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            text?: string | undefined;
+        }, {
+            type: string;
+            text?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        content: {
+            type: string;
+            text?: string | undefined;
+        }[];
+        role: "user";
+    }, {
+        content: {
+            type: string;
+            text?: string | undefined;
+        }[];
+        role: "user";
+    }>;
+}, "strict", z.ZodTypeAny, {
+    message: {
+        content: {
+            type: string;
+            text?: string | undefined;
+        }[];
+        role: "user";
+    };
+    type: "user";
+    timestamp: string;
+    sessionId: string;
+    cwd: string;
+}, {
+    message: {
+        content: {
+            type: string;
+            text?: string | undefined;
+        }[];
+        role: "user";
+    };
+    type: "user";
+    timestamp: string;
+    sessionId: string;
+    cwd: string;
+}>;
+export type AnyEntry = z.infer<typeof AnyEntrySchema>;
+export declare const isUserEntry: (entry: AnyEntry) => entry is User;
+//# sourceMappingURL=entries.d.ts.map

package/dist/esm/providers/opencode/entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../../../src/providers/opencode/entries.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBZ,CAAA;AAEX,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAI7C;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAa,CAAA;AAExC,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAIrD,eAAO,MAAM,WAAW,GAAI,OAAO,QAAQ,KAAG,KAAK,IAAI,IAA6B,CAAA"}