@goscribe/server 1.0.5 → 1.0.7

package/dist/routers/flashcards.js

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+import { TRPCError } from '@trpc/server';
+import { router, authedProcedure } from '../trpc.js';
+// Prisma enum values mapped manually to avoid type import issues in ESM
+const ArtifactType = {
+    STUDY_GUIDE: 'STUDY_GUIDE',
+    FLASHCARD_SET: 'FLASHCARD_SET',
+    WORKSHEET: 'WORKSHEET',
+    MEETING_SUMMARY: 'MEETING_SUMMARY',
+    PODCAST_EPISODE: 'PODCAST_EPISODE',
+};
+export const flashcards = router({
+    listSets: authedProcedure
+        .input(z.object({ workspaceId: z.string().uuid() }))
+        .query(async ({ ctx, input }) => {
+        const workspace = await ctx.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: ctx.session.user.id },
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ctx.db.artifact.findMany({
+            where: { workspaceId: input.workspaceId, type: ArtifactType.FLASHCARD_SET },
+            orderBy: { updatedAt: 'desc' },
+        });
+    }),
+    createSet: authedProcedure
+        .input(z.object({ workspaceId: z.string().uuid(), title: z.string().min(1).max(120) }))
+        .mutation(async ({ ctx, input }) => {
+        const workspace = await ctx.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: ctx.session.user.id },
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ctx.db.artifact.create({
+            data: {
+                workspaceId: input.workspaceId,
+                type: ArtifactType.FLASHCARD_SET,
+                title: input.title,
+                createdById: ctx.session.user.id,
+            },
+        });
+    }),
+    getSet: authedProcedure
+        .input(z.object({ setId: z.string().uuid() }))
+        .query(async ({ ctx, input }) => {
+        const set = await ctx.db.artifact.findFirst({
+            where: {
+                id: input.setId,
+                type: ArtifactType.FLASHCARD_SET,
+                workspace: { ownerId: ctx.session.user.id },
+            },
+            include: { flashcards: true },
+        });
+        if (!set)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return set;
+    }),
+    createCard: authedProcedure
+        .input(z.object({
+        setId: z.string().uuid(),
+        front: z.string().min(1),
+        back: z.string().min(1),
+        tags: z.array(z.string()).optional(),
+        order: z.number().int().optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const set = await ctx.db.artifact.findFirst({
+            where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+        });
+        if (!set)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ctx.db.flashcard.create({
+            data: {
+                artifactId: input.setId,
+                front: input.front,
+                back: input.back,
+                tags: input.tags ?? [],
+                order: input.order ?? 0,
+            },
+        });
+    }),
+    updateCard: authedProcedure
+        .input(z.object({
+        cardId: z.string().uuid(),
+        front: z.string().optional(),
+        back: z.string().optional(),
+        tags: z.array(z.string()).optional(),
+        order: z.number().int().optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const card = await ctx.db.flashcard.findFirst({
+            where: { id: input.cardId, artifact: { type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } } },
+        });
+        if (!card)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ctx.db.flashcard.update({
+            where: { id: input.cardId },
+            data: {
+                front: input.front ?? card.front,
+                back: input.back ?? card.back,
+                tags: input.tags ?? card.tags,
+                order: input.order ?? card.order,
+            },
+        });
+    }),
+    deleteCard: authedProcedure
+        .input(z.object({ cardId: z.string().uuid() }))
+        .mutation(async ({ ctx, input }) => {
+        const card = await ctx.db.flashcard.findFirst({
+            where: { id: input.cardId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
+        });
+        if (!card)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        await ctx.db.flashcard.delete({ where: { id: input.cardId } });
+        return true;
+    }),
+    deleteSet: authedProcedure
+        .input(z.object({ setId: z.string().uuid() }))
+        .mutation(async ({ ctx, input }) => {
+        const deleted = await ctx.db.artifact.deleteMany({
+            where: { id: input.setId, type: ArtifactType.FLASHCARD_SET, workspace: { ownerId: ctx.session.user.id } },
+        });
+        if (deleted.count === 0)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return true;
+    }),
+});

package/dist/routers/sample.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sampleRouter = void 0;
+const zod_1 = require("zod");
+const trpc_1 = require("../trpc");
+exports.sampleRouter = (0, trpc_1.router)({
+    // GET-like: query without input
+    hello: trpc_1.publicProcedure.query(() => {
+        return { message: 'Hello from tRPC + Express 👋' };
+    }),
+    // Mutation with Zod input
+    echo: trpc_1.publicProcedure
+        .input(zod_1.z.object({ text: zod_1.z.string().min(1) }))
+        .mutation(({ input }) => {
+        return { echoed: input.text };
+    }),
+    // Authed query
+    me: trpc_1.authedProcedure.query(({ ctx }) => {
+        return { userId: ctx.user.id, role: ctx.user.role };
+    }),
+});

package/dist/routers/worksheets.d.ts

@@ -0,0 +1,129 @@
+export declare const worksheets: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
+        session: any;
+        req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+        res: import("express").Response<any, Record<string, any>>;
+        cookies: any;
+    };
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    listSets: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workspaceId: string;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            title: string;
+            workspaceId: string;
+            type: import("@prisma/client").$Enums.ArtifactType;
+            isArchived: boolean;
+            createdById: string | null;
+        }[];
+        meta: object;
+    }>;
+    createSet: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workspaceId: string;
+            title: string;
+        };
+        output: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            title: string;
+            workspaceId: string;
+            type: import("@prisma/client").$Enums.ArtifactType;
+            isArchived: boolean;
+            createdById: string | null;
+        };
+        meta: object;
+    }>;
+    getSet: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            setId: string;
+        };
+        output: {
+            questions: {
+                meta: import("@prisma/client/runtime/library").JsonValue | null;
+                id: string;
+                createdAt: Date;
+                artifactId: string;
+                order: number;
+                prompt: string;
+                answer: string | null;
+                difficulty: import("@prisma/client").$Enums.Difficulty;
+            }[];
+        } & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            title: string;
+            workspaceId: string;
+            type: import("@prisma/client").$Enums.ArtifactType;
+            isArchived: boolean;
+            createdById: string | null;
+        };
+        meta: object;
+    }>;
+    createQuestion: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            setId: string;
+            prompt: string;
+            answer?: string | undefined;
+            difficulty?: "EASY" | "MEDIUM" | "HARD" | undefined;
+            order?: number | undefined;
+            meta?: Record<string, unknown> | undefined;
+        };
+        output: {
+            meta: import("@prisma/client/runtime/library").JsonValue | null;
+            id: string;
+            createdAt: Date;
+            artifactId: string;
+            order: number;
+            prompt: string;
+            answer: string | null;
+            difficulty: import("@prisma/client").$Enums.Difficulty;
+        };
+        meta: object;
+    }>;
+    updateQuestion: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            questionId: string;
+            prompt?: string | undefined;
+            answer?: string | undefined;
+            difficulty?: "EASY" | "MEDIUM" | "HARD" | undefined;
+            order?: number | undefined;
+            meta?: Record<string, unknown> | undefined;
+        };
+        output: {
+            meta: import("@prisma/client/runtime/library").JsonValue | null;
+            id: string;
+            createdAt: Date;
+            artifactId: string;
+            order: number;
+            prompt: string;
+            answer: string | null;
+            difficulty: import("@prisma/client").$Enums.Difficulty;
+        };
+        meta: object;
+    }>;
+    deleteQuestion: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            questionId: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+    deleteSet: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            setId: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+}>>;

package/dist/routers/worksheets.js

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+import { TRPCError } from '@trpc/server';
+import { router, authedProcedure } from '../trpc.js';
+// Avoid importing Prisma enums directly; mirror values as string literals
+const ArtifactType = {
+    WORKSHEET: 'WORKSHEET',
+};
+const Difficulty = {
+    EASY: 'EASY',
+    MEDIUM: 'MEDIUM',
+    HARD: 'HARD',
+};
+export const worksheets = router({
+    // List all worksheet artifacts for a workspace
+    listSets: authedProcedure
+        .input(z.object({ workspaceId: z.string().uuid() }))
+        .query(async ({ ctx, input }) => {
+        const workspace = await ctx.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: ctx.session.user.id },
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ctx.db.artifact.findMany({
+            where: { workspaceId: input.workspaceId, type: ArtifactType.WORKSHEET },
+            orderBy: { updatedAt: 'desc' },
+        });
+    }),
+    // Create a worksheet set
+    createSet: authedProcedure
+        .input(z.object({ workspaceId: z.string().uuid(), title: z.string().min(1).max(120) }))
+        .mutation(async ({ ctx, input }) => {
+        const workspace = await ctx.db.workspace.findFirst({
+            where: { id: input.workspaceId, ownerId: ctx.session.user.id },
+        });
+        if (!workspace)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ctx.db.artifact.create({
+            data: {
+                workspaceId: input.workspaceId,
+                type: ArtifactType.WORKSHEET,
+                title: input.title,
+                createdById: ctx.session.user.id,
+            },
+        });
+    }),
+    // Get a worksheet with its questions
+    getSet: authedProcedure
+        .input(z.object({ setId: z.string().uuid() }))
+        .query(async ({ ctx, input }) => {
+        const set = await ctx.db.artifact.findFirst({
+            where: {
+                id: input.setId,
+                type: ArtifactType.WORKSHEET,
+                workspace: { ownerId: ctx.session.user.id },
+            },
+            include: { questions: true },
+        });
+        if (!set)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return set;
+    }),
+    // Add a question to a worksheet
+    createQuestion: authedProcedure
+        .input(z.object({
+        setId: z.string().uuid(),
+        prompt: z.string().min(1),
+        answer: z.string().optional(),
+        difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
+        order: z.number().int().optional(),
+        meta: z.record(z.string(), z.unknown()).optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const set = await ctx.db.artifact.findFirst({
+            where: { id: input.setId, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
+        });
+        if (!set)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ctx.db.worksheetQuestion.create({
+            data: {
+                artifactId: input.setId,
+                prompt: input.prompt,
+                answer: input.answer,
+                difficulty: (input.difficulty ?? Difficulty.MEDIUM),
+                order: input.order ?? 0,
+                meta: input.meta,
+            },
+        });
+    }),
+    // Update a question
+    updateQuestion: authedProcedure
+        .input(z.object({
+        questionId: z.string().uuid(),
+        prompt: z.string().optional(),
+        answer: z.string().optional(),
+        difficulty: z.enum(['EASY', 'MEDIUM', 'HARD']).optional(),
+        order: z.number().int().optional(),
+        meta: z.record(z.string(), z.unknown()).optional(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const q = await ctx.db.worksheetQuestion.findFirst({
+            where: { id: input.questionId, artifact: { type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } } },
+        });
+        if (!q)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ctx.db.worksheetQuestion.update({
+            where: { id: input.questionId },
+            data: {
+                prompt: input.prompt ?? q.prompt,
+                answer: input.answer ?? q.answer,
+                difficulty: (input.difficulty ?? q.difficulty),
+                order: input.order ?? q.order,
+                meta: (input.meta ?? q.meta),
+            },
+        });
+    }),
+    // Delete a question
+    deleteQuestion: authedProcedure
+        .input(z.object({ questionId: z.string().uuid() }))
+        .mutation(async ({ ctx, input }) => {
+        const q = await ctx.db.worksheetQuestion.findFirst({
+            where: { id: input.questionId, artifact: { workspace: { ownerId: ctx.session.user.id } } },
+        });
+        if (!q)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        await ctx.db.worksheetQuestion.delete({ where: { id: input.questionId } });
+        return true;
+    }),
+    // Delete a worksheet set and its questions
+    deleteSet: authedProcedure
+        .input(z.object({ setId: z.string().uuid() }))
+        .mutation(async ({ ctx, input }) => {
+        const deleted = await ctx.db.artifact.deleteMany({
+            where: { id: input.setId, type: ArtifactType.WORKSHEET, workspace: { ownerId: ctx.session.user.id } },
+        });
+        if (deleted.count === 0)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return true;
+    }),
+});

package/dist/routers/workspace.d.ts

@@ -4,7 +4,7 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;
-        cookies: Record<string, string | undefined>;
+        cookies: any;
     };
     meta: object;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
@@ -51,7 +51,7 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
             title: string;
             description: string | null;
             folderId: string | null;
-        } | null;
+        };
         meta: object;
     }>;
     update: import("@trpc/server").TRPCMutationProcedure<{
@@ -98,7 +98,7 @@ export declare const workspace: import("@trpc/server").TRPCBuiltRouter<{
             fileId: string[];
             id: string;
         };
-        output: import("@prisma/client").Prisma.BatchPayload;
+        output: boolean;
         meta: object;
     }>;
 }>>;

package/dist/routers/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/routers/workspace.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuJpB,CAAC"}

package/dist/routers/workspace.js

@@ -1,14 +1,16 @@
 import { z } from 'zod';
+import { TRPCError } from '@trpc/server';
 import { router, authedProcedure } from '../trpc.js';
 import { bucket } from '../lib/storage.js';
 export const workspace = router({
-    // Mutation with Zod input
+    // List current user's workspaces
     list: authedProcedure
-        .query(async ({ ctx, input }) => {
+        .query(async ({ ctx }) => {
         const workspaces = await ctx.db.workspace.findMany({
             where: {
-                ownerId: ctx.session?.user.id,
+                ownerId: ctx.session.user.id,
             },
+            orderBy: { updatedAt: 'desc' },
         });
         return workspaces;
     }),
@@ -17,25 +19,27 @@ export const workspace = router({
         name: z.string().min(1).max(100),
         description: z.string().max(500).optional(),
     }))
-        .mutation(({ ctx, input }) => {
-        return ctx.db.workspace.create({
+        .mutation(async ({ ctx, input }) => {
+        const ws = await ctx.db.workspace.create({
             data: {
                 title: input.name,
                 description: input.description,
-                ownerId: ctx.session?.user.id,
+                ownerId: ctx.session.user.id,
             },
         });
+        return ws;
     }),
     get: authedProcedure
         .input(z.object({
         id: z.string().uuid(),
     }))
-        .query(({ ctx, input }) => {
-        return ctx.db.workspace.findUnique({
-            where: {
-                id: input.id,
-            },
+        .query(async ({ ctx, input }) => {
+        const ws = await ctx.db.workspace.findFirst({
+            where: { id: input.id, ownerId: ctx.session.user.id },
         });
+        if (!ws)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        return ws;
     }),
     update: authedProcedure
         .input(z.object({
@@ -43,27 +47,31 @@ export const workspace = router({
         name: z.string().min(1).max(100).optional(),
         description: z.string().max(500).optional(),
     }))
-        .mutation(({ ctx, input }) => {
-        return ctx.db.workspace.update({
-            where: {
-                id: input.id,
-            },
+        .mutation(async ({ ctx, input }) => {
+        const existed = await ctx.db.workspace.findFirst({
+            where: { id: input.id, ownerId: ctx.session.user.id },
+        });
+        if (!existed)
+            throw new TRPCError({ code: 'NOT_FOUND' });
+        const updated = await ctx.db.workspace.update({
+            where: { id: input.id },
             data: {
-                title: input.name,
+                title: input.name ?? existed.title,
                 description: input.description,
             },
         });
+        return updated;
     }),
     delete: authedProcedure
         .input(z.object({
         id: z.string().uuid(),
     }))
-        .mutation(({ ctx, input }) => {
-        ctx.db.workspace.delete({
-            where: {
-                id: input.id,
-            },
+        .mutation(async ({ ctx, input }) => {
+        const deleted = await ctx.db.workspace.deleteMany({
+            where: { id: input.id, ownerId: ctx.session.user.id },
         });
+        if (deleted.count === 0)
+            throw new TRPCError({ code: 'NOT_FOUND' });
         return true;
     }),
     uploadFiles: authedProcedure
@@ -76,6 +84,10 @@ export const workspace = router({
         })),
     }))
         .mutation(async ({ ctx, input }) => {
+        // ensure workspace belongs to user
+        const ws = await ctx.db.workspace.findFirst({ where: { id: input.id, ownerId: ctx.session.user.id } });
+        if (!ws)
+            throw new TRPCError({ code: 'NOT_FOUND' });
         const results = [];
         for (const file of input.files) {
             // 1. Insert into DB
@@ -116,29 +128,31 @@ export const workspace = router({
         fileId: z.array(z.string().uuid()),
         id: z.string().uuid(),
     }))
-        .mutation(({ ctx, input }) => {
-        const files = ctx.db.fileAsset.findMany({
+        .mutation(async ({ ctx, input }) => {
+        // ensure files are in the user's workspace
+        const files = await ctx.db.fileAsset.findMany({
             where: {
                 id: { in: input.fileId },
                 workspaceId: input.id,
+                userId: ctx.session.user.id,
             },
         });
-        // Delete from GCS
-        files.then((fileRecords) => {
-            fileRecords.forEach((file) => {
-                if (file.bucket && file.objectKey) {
-                    const gcsFile = bucket.file(file.objectKey);
-                    gcsFile.delete({ ignoreNotFound: true }).catch((err) => {
-                        console.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
-                    });
-                }
-            });
-        });
-        return ctx.db.fileAsset.deleteMany({
+        // Delete from GCS (best-effort)
+        for (const file of files) {
+            if (file.bucket && file.objectKey) {
+                const gcsFile = bucket.file(file.objectKey);
+                gcsFile.delete({ ignoreNotFound: true }).catch((err) => {
+                    console.error(`Error deleting file ${file.objectKey} from bucket ${file.bucket}:`, err);
+                });
+            }
+        }
+        await ctx.db.fileAsset.deleteMany({
             where: {
                 id: { in: input.fileId },
                 workspaceId: input.id,
+                userId: ctx.session.user.id,
             },
         });
+        return true;
     }),
 });

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":""}

package/dist/trpc.d.ts

@@ -4,7 +4,7 @@ export declare const router: import("@trpc/server").TRPCRouterBuilder<{
         session: any;
         req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
         res: import("express").Response<any, Record<string, any>>;
-        cookies: Record<string, string | undefined>;
+        cookies: any;
     };
     meta: object;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
@@ -15,20 +15,20 @@ export declare const middleware: <$ContextOverrides>(fn: import("@trpc/server").
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: Record<string, string | undefined>;
+    cookies: any;
 }, object, object, $ContextOverrides, unknown>) => import("@trpc/server").TRPCMiddlewareBuilder<{
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: Record<string, string | undefined>;
+    cookies: any;
 }, object, $ContextOverrides, unknown>;
 export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<{
     db: import("@prisma/client").PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: Record<string, string | undefined>;
+    cookies: any;
 }, object, object, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
 /** Exported authed procedure */
 export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilder<{
@@ -36,7 +36,7 @@ export declare const authedProcedure: import("@trpc/server").TRPCProcedureBuilde
     session: any;
     req: import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
     res: import("express").Response<any, Record<string, any>>;
-    cookies: Record<string, string | undefined>;
+    cookies: any;
 }, object, {
     session: any;
 }, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;

package/dist/trpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../src/trpc.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,MAAM;;;;;;;;;;EAAW,CAAC;AAC/B,eAAO,MAAM,UAAU;;;;;;;;;;sCAAe,CAAC;AACvC,eAAO,MAAM,eAAe;;;;;yLAAc,CAAC;AAsB3C,gCAAgC;AAChC,eAAO,MAAM,eAAe;;;;;;;;;;yKAAgC,CAAC"}