@locusai/shared 0.4.6 → 0.4.9

package/dist/index.js

@@ -1,3 +1,884 @@
-export * from "./common";
-export * from "./enums";
-export * from "./models";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  isJwtUser: () => isJwtUser,
+  isApiKeyUser: () => isApiKeyUser,
+  getAuthUserId: () => getAuthUserId,
+  generateUUID: () => generateUUID,
+  WorkspacesResponseSchema: () => WorkspacesResponseSchema,
+  WorkspaceStatsSchema: () => WorkspaceStatsSchema,
+  WorkspaceStatsResponseSchema: () => WorkspaceStatsResponseSchema,
+  WorkspaceSchema: () => WorkspaceSchema,
+  WorkspaceResponseSchema: () => WorkspaceResponseSchema,
+  WorkspaceIdParamSchema: () => WorkspaceIdParamSchema,
+  WorkspaceCreatedPayloadSchema: () => WorkspaceCreatedPayloadSchema,
+  WorkspaceAndUserParamSchema: () => WorkspaceAndUserParamSchema,
+  VerifyOtpSchema: () => VerifyOtpSchema,
+  UserSchema: () => UserSchema,
+  UserRole: () => UserRole,
+  UpdateWorkspaceSchema: () => UpdateWorkspaceSchema,
+  UpdateUserSchema: () => UpdateUserSchema,
+  UpdateTaskSchema: () => UpdateTaskSchema,
+  UpdateSprintSchema: () => UpdateSprintSchema,
+  UpdateOrganizationSchema: () => UpdateOrganizationSchema,
+  UpdateDocSchema: () => UpdateDocSchema,
+  UpdateDocGroupSchema: () => UpdateDocGroupSchema,
+  UnlockSchema: () => UnlockSchema,
+  TasksResponseSchema: () => TasksResponseSchema,
+  TaskStatus: () => TaskStatus,
+  TaskSchema: () => TaskSchema,
+  TaskResponseSchema: () => TaskResponseSchema,
+  TaskQuerySchema: () => TaskQuerySchema,
+  TaskPriority: () => TaskPriority,
+  TaskIdParamSchema: () => TaskIdParamSchema,
+  TaskIdOnlyParamSchema: () => TaskIdOnlyParamSchema,
+  TaskDeletedPayloadSchema: () => TaskDeletedPayloadSchema,
+  TaskCreatedPayloadSchema: () => TaskCreatedPayloadSchema,
+  SuccessResponseSchema: () => SuccessResponseSchema,
+  StatusChangedPayloadSchema: () => StatusChangedPayloadSchema,
+  SprintsResponseSchema: () => SprintsResponseSchema,
+  SprintStatusChangedPayloadSchema: () => SprintStatusChangedPayloadSchema,
+  SprintStatus: () => SprintStatus,
+  SprintSchema: () => SprintSchema,
+  SprintResponseSchema: () => SprintResponseSchema,
+  SprintQuerySchema: () => SprintQuerySchema,
+  SprintIdParamSchema: () => SprintIdParamSchema,
+  SprintCreatedPayloadSchema: () => SprintCreatedPayloadSchema,
+  ReportCiResultSchema: () => ReportCiResultSchema,
+  RecordCiSchema: () => RecordCiSchema,
+  PaginationRequestSchema: () => PaginationRequestSchema,
+  PaginationMetaSchema: () => PaginationMetaSchema,
+  OtpRequestSchema: () => OtpRequestSchema,
+  OrganizationsResponseSchema: () => OrganizationsResponseSchema,
+  OrganizationSchema: () => OrganizationSchema,
+  OrganizationResponseSchema: () => OrganizationResponseSchema,
+  OrgIdParamSchema: () => OrgIdParamSchema,
+  MembershipWithUserSchema: () => MembershipWithUserSchema,
+  MembershipRole: () => MembershipRole,
+  MembershipResponseSchema: () => MembershipResponseSchema,
+  MembershipIdParamSchema: () => MembershipIdParamSchema,
+  MembersResponseSchema: () => MembersResponseSchema,
+  MemberInvitedPayloadSchema: () => MemberInvitedPayloadSchema,
+  MemberAddedPayloadSchema: () => MemberAddedPayloadSchema,
+  LockSchema: () => LockSchema,
+  JwtAuthUserSchema: () => JwtAuthUserSchema,
+  JWTPayloadSchema: () => JWTPayloadSchema,
+  InvitationsResponseSchema: () => InvitationsResponseSchema,
+  InvitationVerifyParamSchema: () => InvitationVerifyParamSchema,
+  InvitationSchema: () => InvitationSchema,
+  InvitationResponseSchema: () => InvitationResponseSchema,
+  InvitationQuerySchema: () => InvitationQuerySchema,
+  InvitationIdParamSchema: () => InvitationIdParamSchema,
+  EventsResponseSchema: () => EventsResponseSchema,
+  EventType: () => EventType,
+  EventSchema: () => EventSchema,
+  EventResponseSchema: () => EventResponseSchema,
+  EventQuerySchema: () => EventQuerySchema,
+  EventPayloadSchema: () => EventPayloadSchema,
+  ErrorResponseSchema: () => ErrorResponseSchema,
+  DocsResponseSchema: () => DocsResponseSchema,
+  DocSchema: () => DocSchema,
+  DocResponseSchema: () => DocResponseSchema,
+  DocQuerySchema: () => DocQuerySchema,
+  DocIdParamSchema: () => DocIdParamSchema,
+  DocGroupsResponseSchema: () => DocGroupsResponseSchema,
+  DocGroupSchemaForDoc: () => DocGroupSchemaForDoc,
+  DocGroupSchema: () => DocGroupSchema,
+  DocGroupResponseSchema: () => DocGroupResponseSchema,
+  DocGroupIdParamSchema: () => DocGroupIdParamSchema,
+  DispatchTaskSchema: () => DispatchTaskSchema,
+  CreateWorkspaceSchema: () => CreateWorkspaceSchema,
+  CreateUserSchema: () => CreateUserSchema,
+  CreateTaskSchema: () => CreateTaskSchema,
+  CreateSprintSchema: () => CreateSprintSchema,
+  CreateOrganizationSchema: () => CreateOrganizationSchema,
+  CreateInvitationSchema: () => CreateInvitationSchema,
+  CreateDocSchema: () => CreateDocSchema,
+  CreateDocGroupSchema: () => CreateDocGroupSchema,
+  CreateArtifactSchema: () => CreateArtifactSchema,
+  CreateApiKeySchema: () => CreateApiKeySchema,
+  CompleteRegistrationSchema: () => CompleteRegistrationSchema,
+  CommentSchema: () => CommentSchema,
+  CommentResponseSchema: () => CommentResponseSchema,
+  CommentAddedPayloadSchema: () => CommentAddedPayloadSchema,
+  CiRanPayloadSchema: () => CiRanPayloadSchema,
+  ChecklistItemSchema: () => ChecklistItemSchema,
+  ChecklistInitializedPayloadSchema: () => ChecklistInitializedPayloadSchema,
+  BaseEntitySchema: () => BaseEntitySchema,
+  AuthenticatedUserSchema: () => AuthenticatedUserSchema,
+  AuthResponseSchema: () => AuthResponseSchema,
+  AuthContextSchema: () => AuthContextSchema,
+  AssigneeRole: () => AssigneeRole,
+  ArtifactsResponseSchema: () => ArtifactsResponseSchema,
+  ArtifactSchema: () => ArtifactSchema,
+  ArtifactResponseSchema: () => ArtifactResponseSchema,
+  ArtifactParamSchema: () => ArtifactParamSchema,
+  ApiResponseSchema: () => ApiResponseSchema,
+  ApiKeyQuerySchema: () => ApiKeyQuerySchema,
+  ApiKeyIdParamSchema: () => ApiKeyIdParamSchema,
+  ApiKeyAuthUserSchema: () => ApiKeyAuthUserSchema,
+  AddWorkspaceMemberSchema: () => AddWorkspaceMemberSchema,
+  AddMemberSchema: () => AddMemberSchema,
+  AddCommentSchema: () => AddCommentSchema,
+  ActivityResponseSchema: () => ActivityResponseSchema,
+  AcceptanceItemSchema: () => AcceptanceItemSchema,
+  AcceptInvitationSchema: () => AcceptInvitationSchema,
+  AcceptInvitationResponseSchema: () => AcceptInvitationResponseSchema,
+  APIKeySchema: () => APIKeySchema,
+  APIKeyCreateResponseSchema: () => APIKeyCreateResponseSchema
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/common.ts
+var import_zod = require("zod");
+var BaseEntitySchema = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  createdAt: import_zod.z.union([import_zod.z.date(), import_zod.z.number()]),
+  updatedAt: import_zod.z.union([import_zod.z.date(), import_zod.z.number()])
+});
+var PaginationMetaSchema = import_zod.z.object({
+  page: import_zod.z.number(),
+  limit: import_zod.z.number(),
+  total: import_zod.z.number(),
+  totalPages: import_zod.z.number()
+});
+var PaginationRequestSchema = import_zod.z.object({
+  page: import_zod.z.coerce.number().int().min(1).default(1),
+  limit: import_zod.z.coerce.number().int().min(1).max(100).default(20)
+});
+var ApiResponseSchema = import_zod.z.object({
+  success: import_zod.z.boolean(),
+  data: import_zod.z.unknown().optional(),
+  error: import_zod.z.object({
+    code: import_zod.z.string(),
+    message: import_zod.z.string(),
+    details: import_zod.z.unknown().optional()
+  }).optional(),
+  meta: import_zod.z.object({
+    pagination: PaginationMetaSchema.optional(),
+    timestamp: import_zod.z.string(),
+    path: import_zod.z.string()
+  }).optional()
+});
+var SuccessResponseSchema = import_zod.z.object({
+  success: import_zod.z.literal(true),
+  message: import_zod.z.string().optional()
+});
+var ErrorResponseSchema = import_zod.z.object({
+  success: import_zod.z.literal(false),
+  error: import_zod.z.object({
+    code: import_zod.z.string(),
+    message: import_zod.z.string(),
+    details: import_zod.z.unknown().optional()
+  })
+});
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+// src/enums.ts
+var UserRole;
+((UserRole2) => {
+  UserRole2["USER"] = "USER";
+  UserRole2["ADMIN"] = "ADMIN";
+})(UserRole ||= {});
+var MembershipRole;
+((MembershipRole2) => {
+  MembershipRole2["OWNER"] = "OWNER";
+  MembershipRole2["ADMIN"] = "ADMIN";
+  MembershipRole2["MEMBER"] = "MEMBER";
+  MembershipRole2["VIEWER"] = "VIEWER";
+})(MembershipRole ||= {});
+var TaskStatus;
+((TaskStatus2) => {
+  TaskStatus2["BACKLOG"] = "BACKLOG";
+  TaskStatus2["IN_PROGRESS"] = "IN_PROGRESS";
+  TaskStatus2["REVIEW"] = "REVIEW";
+  TaskStatus2["VERIFICATION"] = "VERIFICATION";
+  TaskStatus2["DONE"] = "DONE";
+  TaskStatus2["BLOCKED"] = "BLOCKED";
+})(TaskStatus ||= {});
+var TaskPriority;
+((TaskPriority2) => {
+  TaskPriority2["LOW"] = "LOW";
+  TaskPriority2["MEDIUM"] = "MEDIUM";
+  TaskPriority2["HIGH"] = "HIGH";
+  TaskPriority2["CRITICAL"] = "CRITICAL";
+})(TaskPriority ||= {});
+var AssigneeRole;
+((AssigneeRole2) => {
+  AssigneeRole2["BACKEND"] = "BACKEND";
+  AssigneeRole2["FRONTEND"] = "FRONTEND";
+  AssigneeRole2["QA"] = "QA";
+  AssigneeRole2["PM"] = "PM";
+  AssigneeRole2["DESIGN"] = "DESIGN";
+})(AssigneeRole ||= {});
+var SprintStatus;
+((SprintStatus2) => {
+  SprintStatus2["PLANNED"] = "PLANNED";
+  SprintStatus2["ACTIVE"] = "ACTIVE";
+  SprintStatus2["COMPLETED"] = "COMPLETED";
+})(SprintStatus ||= {});
+var EventType;
+((EventType2) => {
+  EventType2["TASK_CREATED"] = "TASK_CREATED";
+  EventType2["TASK_UPDATED"] = "TASK_UPDATED";
+  EventType2["TASK_DELETED"] = "TASK_DELETED";
+  EventType2["STATUS_CHANGED"] = "STATUS_CHANGED";
+  EventType2["COMMENT_ADDED"] = "COMMENT_ADDED";
+  EventType2["CI_RAN"] = "CI_RAN";
+  EventType2["WORKSPACE_CREATED"] = "WORKSPACE_CREATED";
+  EventType2["MEMBER_ADDED"] = "MEMBER_ADDED";
+  EventType2["MEMBER_INVITED"] = "MEMBER_INVITED";
+  EventType2["SPRINT_CREATED"] = "SPRINT_CREATED";
+  EventType2["SPRINT_STATUS_CHANGED"] = "SPRINT_STATUS_CHANGED";
+  EventType2["CHECKLIST_INITIALIZED"] = "CHECKLIST_INITIALIZED";
+})(EventType ||= {});
+// src/models/activity.ts
+var import_zod2 = require("zod");
+var CommentSchema = BaseEntitySchema.extend({
+  taskId: import_zod2.z.string().uuid(),
+  author: import_zod2.z.string().min(1),
+  text: import_zod2.z.string().min(1)
+});
+var ArtifactSchema = BaseEntitySchema.extend({
+  taskId: import_zod2.z.string().uuid(),
+  type: import_zod2.z.string().min(1),
+  title: import_zod2.z.string().min(1),
+  contentText: import_zod2.z.string().optional(),
+  filePath: import_zod2.z.string().optional(),
+  url: import_zod2.z.string().optional(),
+  size: import_zod2.z.string().optional(),
+  createdBy: import_zod2.z.string().min(1)
+});
+var TaskCreatedPayloadSchema = import_zod2.z.object({
+  title: import_zod2.z.string()
+});
+var TaskDeletedPayloadSchema = import_zod2.z.object({
+  title: import_zod2.z.string()
+});
+var StatusChangedPayloadSchema = import_zod2.z.object({
+  title: import_zod2.z.string(),
+  oldStatus: import_zod2.z.nativeEnum(TaskStatus),
+  newStatus: import_zod2.z.nativeEnum(TaskStatus)
+});
+var CommentAddedPayloadSchema = import_zod2.z.object({
+  title: import_zod2.z.string(),
+  author: import_zod2.z.string(),
+  text: import_zod2.z.string()
+});
+var WorkspaceCreatedPayloadSchema = import_zod2.z.object({
+  name: import_zod2.z.string()
+});
+var MemberAddedPayloadSchema = import_zod2.z.object({
+  userId: import_zod2.z.string(),
+  role: import_zod2.z.string()
+});
+var MemberInvitedPayloadSchema = import_zod2.z.object({
+  email: import_zod2.z.string()
+});
+var SprintCreatedPayloadSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  sprintId: import_zod2.z.string().uuid()
+});
+var SprintStatusChangedPayloadSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  sprintId: import_zod2.z.string().uuid(),
+  oldStatus: import_zod2.z.nativeEnum(SprintStatus),
+  newStatus: import_zod2.z.nativeEnum(SprintStatus)
+});
+var ChecklistInitializedPayloadSchema = import_zod2.z.object({
+  itemCount: import_zod2.z.number()
+});
+var CiRanPayloadSchema = import_zod2.z.object({
+  preset: import_zod2.z.string(),
+  ok: import_zod2.z.boolean(),
+  summary: import_zod2.z.string(),
+  source: import_zod2.z.string(),
+  deferred: import_zod2.z.boolean(),
+  processed: import_zod2.z.boolean(),
+  commands: import_zod2.z.array(import_zod2.z.object({ cmd: import_zod2.z.string(), exitCode: import_zod2.z.number() }))
+});
+var EventPayloadSchema = import_zod2.z.discriminatedUnion("type", [
+  import_zod2.z.object({
+    type: import_zod2.z.literal("TASK_CREATED" /* TASK_CREATED */),
+    payload: TaskCreatedPayloadSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("TASK_DELETED" /* TASK_DELETED */),
+    payload: TaskDeletedPayloadSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("STATUS_CHANGED" /* STATUS_CHANGED */),
+    payload: StatusChangedPayloadSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("COMMENT_ADDED" /* COMMENT_ADDED */),
+    payload: CommentAddedPayloadSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("WORKSPACE_CREATED" /* WORKSPACE_CREATED */),
+    payload: WorkspaceCreatedPayloadSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("MEMBER_ADDED" /* MEMBER_ADDED */),
+    payload: MemberAddedPayloadSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("MEMBER_INVITED" /* MEMBER_INVITED */),
+    payload: MemberInvitedPayloadSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("SPRINT_CREATED" /* SPRINT_CREATED */),
+    payload: SprintCreatedPayloadSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("SPRINT_STATUS_CHANGED" /* SPRINT_STATUS_CHANGED */),
+    payload: SprintStatusChangedPayloadSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("CHECKLIST_INITIALIZED" /* CHECKLIST_INITIALIZED */),
+    payload: ChecklistInitializedPayloadSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("CI_RAN" /* CI_RAN */),
+    payload: CiRanPayloadSchema
+  })
+]);
+var EventSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  workspaceId: import_zod2.z.string(),
+  taskId: import_zod2.z.string().uuid().optional().nullable(),
+  userId: import_zod2.z.string().optional().nullable(),
+  type: import_zod2.z.nativeEnum(EventType),
+  payload: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()),
+  createdAt: import_zod2.z.union([import_zod2.z.date(), import_zod2.z.number()])
+});
+var ArtifactParamSchema = import_zod2.z.object({
+  taskId: import_zod2.z.string().uuid("Invalid Task ID"),
+  type: import_zod2.z.string().min(1, "Artifact type required"),
+  filename: import_zod2.z.string().min(1, "Filename required")
+});
+var TaskIdOnlyParamSchema = import_zod2.z.object({
+  taskId: import_zod2.z.string().uuid("Invalid Task ID")
+});
+var EventQuerySchema = import_zod2.z.object({
+  taskId: import_zod2.z.string().uuid("Invalid Task ID").optional()
+});
+var EventResponseSchema = import_zod2.z.object({
+  event: EventSchema
+});
+var EventsResponseSchema = import_zod2.z.object({
+  events: import_zod2.z.array(EventSchema)
+});
+var ActivityResponseSchema = import_zod2.z.object({
+  activity: import_zod2.z.array(EventSchema)
+});
+var CommentResponseSchema = import_zod2.z.object({
+  comment: CommentSchema
+});
+var ArtifactResponseSchema = import_zod2.z.object({
+  artifact: ArtifactSchema
+});
+var ArtifactsResponseSchema = import_zod2.z.object({
+  artifacts: import_zod2.z.array(ArtifactSchema)
+});
+var CreateArtifactSchema = import_zod2.z.object({
+  taskId: import_zod2.z.string().uuid(),
+  type: import_zod2.z.string().min(1),
+  title: import_zod2.z.string().min(1),
+  contentText: import_zod2.z.string().optional()
+});
+var ReportCiResultSchema = import_zod2.z.object({
+  workspaceId: import_zod2.z.string().uuid(),
+  taskId: import_zod2.z.string().uuid().optional(),
+  preset: import_zod2.z.string(),
+  ok: import_zod2.z.boolean(),
+  summary: import_zod2.z.string(),
+  commands: import_zod2.z.array(import_zod2.z.object({
+    cmd: import_zod2.z.string(),
+    exitCode: import_zod2.z.number()
+  }))
+});
+// src/models/agent.ts
+var import_zod3 = require("zod");
+var LockSchema = import_zod3.z.object({
+  agentId: import_zod3.z.string().min(1),
+  ttlSeconds: import_zod3.z.number().positive()
+});
+var UnlockSchema = import_zod3.z.object({
+  agentId: import_zod3.z.string().min(1)
+});
+// src/models/auth.ts
+var import_zod5 = require("zod");
+
+// src/models/user.ts
+var import_zod4 = require("zod");
+var UserSchema = BaseEntitySchema.extend({
+  email: import_zod4.z.string().email(),
+  name: import_zod4.z.string().min(1),
+  avatarUrl: import_zod4.z.string().url().nullable().optional(),
+  role: import_zod4.z.nativeEnum(UserRole),
+  orgId: import_zod4.z.string().uuid().optional().nullable(),
+  workspaceId: import_zod4.z.string().uuid().optional().nullable(),
+  companyName: import_zod4.z.string().optional(),
+  userRole: import_zod4.z.string().optional(),
+  teamSize: import_zod4.z.string().optional(),
+  onboardingCompleted: import_zod4.z.boolean().default(false),
+  emailVerified: import_zod4.z.boolean().default(false)
+});
+var CreateUserSchema = import_zod4.z.object({
+  email: import_zod4.z.string().email(),
+  name: import_zod4.z.string().min(1)
+});
+var UpdateUserSchema = UserSchema.partial().omit({
+  id: true,
+  email: true,
+  createdAt: true,
+  updatedAt: true
+});
+
+// src/models/auth.ts
+var JwtAuthUserSchema = import_zod5.z.object({
+  authType: import_zod5.z.literal("jwt"),
+  id: import_zod5.z.string().uuid(),
+  email: import_zod5.z.string().email(),
+  name: import_zod5.z.string(),
+  role: import_zod5.z.nativeEnum(UserRole),
+  orgId: import_zod5.z.string().uuid().nullable().optional(),
+  workspaceId: import_zod5.z.string().uuid().nullable().optional()
+});
+var ApiKeyAuthUserSchema = import_zod5.z.object({
+  authType: import_zod5.z.literal("api_key"),
+  apiKeyId: import_zod5.z.string().uuid(),
+  apiKeyName: import_zod5.z.string(),
+  orgId: import_zod5.z.string().uuid()
+});
+var AuthenticatedUserSchema = import_zod5.z.discriminatedUnion("authType", [
+  JwtAuthUserSchema,
+  ApiKeyAuthUserSchema
+]);
+function isJwtUser(user) {
+  return user.authType === "jwt";
+}
+function isApiKeyUser(user) {
+  return user.authType === "api_key";
+}
+function getAuthUserId(user) {
+  return isJwtUser(user) ? user.id : null;
+}
+var AuthResponseSchema = import_zod5.z.object({
+  token: import_zod5.z.string(),
+  user: UserSchema
+});
+var OtpRequestSchema = import_zod5.z.object({
+  email: import_zod5.z.string().email("Invalid email address")
+});
+var VerifyOtpSchema = import_zod5.z.object({
+  email: import_zod5.z.string().email("Invalid email address"),
+  otp: import_zod5.z.string().length(6, "Verification code must be 6 digits")
+});
+var CompleteRegistrationSchema = import_zod5.z.object({
+  email: import_zod5.z.string().email("Invalid email address"),
+  otp: import_zod5.z.string().length(6, "Verification code must be 6 digits"),
+  name: import_zod5.z.string().min(1, "Name is required").max(100),
+  companyName: import_zod5.z.string().max(100).optional(),
+  teamSize: import_zod5.z.enum(["solo", "2-10", "11-50", "51-200", "200+"]).optional(),
+  userRole: import_zod5.z.enum(["developer", "designer", "product_manager", "other"]).optional(),
+  workspaceName: import_zod5.z.string().max(100).optional(),
+  invitedEmails: import_zod5.z.array(import_zod5.z.string().email()).optional()
+});
+var JWTPayloadSchema = import_zod5.z.object({
+  sub: import_zod5.z.string(),
+  email: import_zod5.z.string().email(),
+  name: import_zod5.z.string(),
+  role: import_zod5.z.string(),
+  orgId: import_zod5.z.string().uuid().optional(),
+  iat: import_zod5.z.number(),
+  exp: import_zod5.z.number()
+});
+var AuthContextSchema = import_zod5.z.object({
+  userId: import_zod5.z.string(),
+  email: import_zod5.z.string().email(),
+  name: import_zod5.z.string(),
+  role: import_zod5.z.string(),
+  orgId: import_zod5.z.string().uuid().optional(),
+  workspaceId: import_zod5.z.string().uuid().optional(),
+  authType: import_zod5.z.enum(["jwt", "api_key", "local"])
+});
+var APIKeySchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  name: import_zod5.z.string(),
+  keyPrefix: import_zod5.z.string(),
+  workspaceId: import_zod5.z.string(),
+  lastUsedAt: import_zod5.z.number().nullable(),
+  createdAt: import_zod5.z.number()
+});
+var APIKeyCreateResponseSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  name: import_zod5.z.string(),
+  keyPrefix: import_zod5.z.string(),
+  key: import_zod5.z.string(),
+  createdAt: import_zod5.z.number()
+});
+var ApiKeyIdParamSchema = import_zod5.z.object({
+  id: import_zod5.z.string().uuid("Invalid API Key ID")
+});
+var ApiKeyQuerySchema = import_zod5.z.object({
+  workspaceId: import_zod5.z.string().uuid("Invalid Workspace ID").optional()
+});
+var CreateApiKeySchema = import_zod5.z.object({
+  workspaceId: import_zod5.z.string().uuid("Invalid Workspace ID").optional(),
+  name: import_zod5.z.string().min(1, "Name is required").max(100),
+  expiresInDays: import_zod5.z.number().int().positive().optional()
+});
+// src/models/ci.ts
+var import_zod6 = require("zod");
+var RecordCiSchema = import_zod6.z.object({
+  taskId: import_zod6.z.string().uuid(),
+  workspaceId: import_zod6.z.string().uuid(),
+  result: import_zod6.z.object({
+    ok: import_zod6.z.boolean(),
+    summary: import_zod6.z.string(),
+    commands: import_zod6.z.array(import_zod6.z.object({
+      cmd: import_zod6.z.string(),
+      exitCode: import_zod6.z.number(),
+      durationMs: import_zod6.z.number().optional(),
+      error: import_zod6.z.string().optional()
+    })),
+    preset: import_zod6.z.string()
+  })
+});
+// src/models/doc.ts
+var import_zod7 = require("zod");
+var DocGroupSchemaForDoc = import_zod7.z.object({
+  id: import_zod7.z.string().uuid(),
+  name: import_zod7.z.string()
+});
+var DocSchema = BaseEntitySchema.extend({
+  workspaceId: import_zod7.z.string().uuid(),
+  groupId: import_zod7.z.string().uuid().nullable().optional(),
+  title: import_zod7.z.string().min(1, "Title is required"),
+  content: import_zod7.z.string().default(""),
+  group: DocGroupSchemaForDoc.nullable().optional()
+});
+var CreateDocSchema = import_zod7.z.object({
+  title: import_zod7.z.string().min(1, "Title is required"),
+  content: import_zod7.z.string().optional(),
+  groupId: import_zod7.z.string().uuid().optional()
+});
+var UpdateDocSchema = import_zod7.z.object({
+  title: import_zod7.z.string().min(1).optional(),
+  content: import_zod7.z.string().optional(),
+  groupId: import_zod7.z.string().uuid().nullable().optional()
+});
+var DocResponseSchema = import_zod7.z.object({
+  doc: DocSchema
+});
+var DocsResponseSchema = import_zod7.z.object({
+  docs: import_zod7.z.array(DocSchema)
+});
+var DocIdParamSchema = import_zod7.z.object({
+  id: import_zod7.z.string().uuid("Invalid Doc ID")
+});
+var DocQuerySchema = import_zod7.z.object({
+  workspaceId: import_zod7.z.string().uuid("Invalid Workspace ID").optional()
+});
+// src/models/doc-group.ts
+var import_zod8 = require("zod");
+var DocGroupSchema = BaseEntitySchema.extend({
+  workspaceId: import_zod8.z.string().uuid(),
+  name: import_zod8.z.string().min(1, "Name is required"),
+  order: import_zod8.z.number().default(0)
+});
+var CreateDocGroupSchema = import_zod8.z.object({
+  name: import_zod8.z.string().min(1, "Name is required"),
+  order: import_zod8.z.number().optional()
+});
+var UpdateDocGroupSchema = import_zod8.z.object({
+  name: import_zod8.z.string().min(1).optional(),
+  order: import_zod8.z.number().optional()
+});
+var DocGroupResponseSchema = import_zod8.z.object({
+  group: DocGroupSchema
+});
+var DocGroupsResponseSchema = import_zod8.z.object({
+  groups: import_zod8.z.array(DocGroupSchema)
+});
+var DocGroupIdParamSchema = import_zod8.z.object({
+  id: import_zod8.z.string().uuid("Invalid Group ID")
+});
+// src/models/invitation.ts
+var import_zod9 = require("zod");
+var InvitationSchema = BaseEntitySchema.extend({
+  orgId: import_zod9.z.string().uuid("Invalid Organization ID"),
+  email: import_zod9.z.string().email("Invalid email address"),
+  role: import_zod9.z.nativeEnum(MembershipRole),
+  token: import_zod9.z.string(),
+  expiresAt: import_zod9.z.number(),
+  acceptedAt: import_zod9.z.number().nullable().optional(),
+  invitedBy: import_zod9.z.string().uuid()
+});
+var CreateInvitationSchema = import_zod9.z.object({
+  orgId: import_zod9.z.string().uuid("Invalid Organization ID"),
+  email: import_zod9.z.string().email("Invalid email address"),
+  role: import_zod9.z.nativeEnum(MembershipRole).default("MEMBER" /* MEMBER */)
+});
+var AcceptInvitationSchema = import_zod9.z.object({
+  token: import_zod9.z.string().min(1, "Invitation token is required"),
+  name: import_zod9.z.string().min(1, "Name is required").optional()
+});
+var InvitationIdParamSchema = import_zod9.z.object({
+  id: import_zod9.z.string().uuid("Invalid Invitation ID")
+});
+var InvitationVerifyParamSchema = import_zod9.z.object({
+  token: import_zod9.z.string().min(1, "Token required")
+});
+var InvitationQuerySchema = import_zod9.z.object({
+  orgId: import_zod9.z.string().uuid("Invalid Organization ID").optional()
+});
+var InvitationResponseSchema = import_zod9.z.object({
+  invitation: InvitationSchema,
+  userExists: import_zod9.z.boolean().optional()
+});
+var InvitationsResponseSchema = import_zod9.z.object({
+  invitations: import_zod9.z.array(InvitationSchema)
+});
+var AcceptInvitationResponseSchema = import_zod9.z.object({
+  membership: import_zod9.z.object({
+    id: import_zod9.z.string().uuid(),
+    userId: import_zod9.z.string().uuid(),
+    orgId: import_zod9.z.string().uuid(),
+    role: import_zod9.z.nativeEnum(MembershipRole),
+    createdAt: import_zod9.z.number()
+  })
+});
+// src/models/organization.ts
+var import_zod10 = require("zod");
+var OrganizationSchema = BaseEntitySchema.extend({
+  name: import_zod10.z.string().min(1, "Name is required").max(100),
+  avatarUrl: import_zod10.z.string().url("Invalid avatar URL").nullable().optional().or(import_zod10.z.literal(""))
+});
+var CreateOrganizationSchema = import_zod10.z.object({
+  name: import_zod10.z.string().min(1, "Name is required").max(100),
+  avatarUrl: import_zod10.z.string().url("Invalid avatar URL").optional().or(import_zod10.z.literal(""))
+});
+var UpdateOrganizationSchema = OrganizationSchema.partial().omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+});
+var AddMemberSchema = import_zod10.z.object({
+  userId: import_zod10.z.string().uuid("Invalid User ID"),
+  role: import_zod10.z.enum(["ADMIN", "MEMBER"]).default("MEMBER")
+});
+var MembershipWithUserSchema = import_zod10.z.object({
+  id: import_zod10.z.string().uuid(),
+  userId: import_zod10.z.string().uuid(),
+  orgId: import_zod10.z.string().uuid(),
+  role: import_zod10.z.string(),
+  createdAt: import_zod10.z.number(),
+  user: import_zod10.z.object({
+    id: import_zod10.z.string().uuid(),
+    email: import_zod10.z.string().email(),
+    name: import_zod10.z.string(),
+    avatarUrl: import_zod10.z.string().url().nullable().optional()
+  })
+});
+var OrgIdParamSchema = import_zod10.z.object({
+  orgId: import_zod10.z.string().uuid("Invalid Organization ID")
+});
+var MembershipIdParamSchema = import_zod10.z.object({
+  id: import_zod10.z.string().uuid("Invalid Membership ID")
+});
+var OrganizationResponseSchema = import_zod10.z.object({
+  organization: OrganizationSchema
+});
+var OrganizationsResponseSchema = import_zod10.z.object({
+  organizations: import_zod10.z.array(OrganizationSchema)
+});
+var MembersResponseSchema = import_zod10.z.object({
+  members: import_zod10.z.array(MembershipWithUserSchema)
+});
+var MembershipResponseSchema = import_zod10.z.object({
+  membership: MembershipWithUserSchema
+});
+// src/models/sprint.ts
+var import_zod11 = require("zod");
+var SprintSchema = BaseEntitySchema.extend({
+  workspaceId: import_zod11.z.string().uuid().nullable().optional(),
+  name: import_zod11.z.string().min(1, "Name is required").max(100),
+  status: import_zod11.z.nativeEnum(SprintStatus),
+  startDate: import_zod11.z.union([import_zod11.z.date(), import_zod11.z.number()]).nullable().optional(),
+  endDate: import_zod11.z.union([import_zod11.z.date(), import_zod11.z.number()]).nullable().optional(),
+  mindmap: import_zod11.z.string().nullable().optional(),
+  mindmapUpdatedAt: import_zod11.z.union([import_zod11.z.date(), import_zod11.z.number()]).nullable().optional()
+});
+var CreateSprintSchema = import_zod11.z.object({
+  name: import_zod11.z.string().min(1, "Name is required").max(100),
+  startDate: import_zod11.z.union([import_zod11.z.coerce.date(), import_zod11.z.number()]).optional(),
+  endDate: import_zod11.z.union([import_zod11.z.coerce.date(), import_zod11.z.number()]).optional()
+});
+var UpdateSprintSchema = SprintSchema.partial().omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({
+  name: import_zod11.z.string().min(1).max(100).optional(),
+  startDate: import_zod11.z.union([import_zod11.z.coerce.date(), import_zod11.z.number()]).optional().nullable(),
+  endDate: import_zod11.z.union([import_zod11.z.coerce.date(), import_zod11.z.number()]).optional().nullable(),
+  mindmapUpdatedAt: import_zod11.z.union([import_zod11.z.coerce.date(), import_zod11.z.number()]).optional().nullable()
+});
+var SprintIdParamSchema = import_zod11.z.object({
+  id: import_zod11.z.string().uuid("Invalid Sprint ID")
+});
+var SprintQuerySchema = import_zod11.z.object({});
+var SprintResponseSchema = import_zod11.z.object({
+  sprint: SprintSchema
+});
+var SprintsResponseSchema = import_zod11.z.object({
+  sprints: import_zod11.z.array(SprintSchema)
+});
+// src/models/task.ts
+var import_zod12 = require("zod");
+var AcceptanceItemSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  text: import_zod12.z.string(),
+  done: import_zod12.z.boolean()
+});
+var TaskSchema = BaseEntitySchema.extend({
+  workspaceId: import_zod12.z.string().uuid().nullable().optional(),
+  title: import_zod12.z.string().min(1, "Title is required").max(200),
+  description: import_zod12.z.string().default(""),
+  status: import_zod12.z.nativeEnum(TaskStatus).default("BACKLOG" /* BACKLOG */),
+  priority: import_zod12.z.nativeEnum(TaskPriority).default("MEDIUM" /* MEDIUM */),
+  labels: import_zod12.z.array(import_zod12.z.string()).default([]),
+  assigneeRole: import_zod12.z.nativeEnum(AssigneeRole).nullable().optional(),
+  assignedTo: import_zod12.z.string().nullable().optional(),
+  sprintId: import_zod12.z.string().uuid().nullable().optional(),
+  parentId: import_zod12.z.string().uuid().nullable().optional(),
+  dueDate: import_zod12.z.union([import_zod12.z.date(), import_zod12.z.number()]).nullable().optional(),
+  acceptanceChecklist: import_zod12.z.array(AcceptanceItemSchema).default([]),
+  comments: import_zod12.z.array(CommentSchema).default([]),
+  activityLog: import_zod12.z.array(EventSchema).default([]),
+  docs: import_zod12.z.array(DocSchema).default([])
+});
+var CreateTaskSchema = import_zod12.z.object({
+  title: import_zod12.z.string().min(1, "Title is required").max(200),
+  description: import_zod12.z.string().optional().default(""),
+  status: import_zod12.z.nativeEnum(TaskStatus).optional().default("BACKLOG" /* BACKLOG */),
+  priority: import_zod12.z.nativeEnum(TaskPriority).optional().default("MEDIUM" /* MEDIUM */),
+  labels: import_zod12.z.array(import_zod12.z.string()).optional().default([]),
+  assigneeRole: import_zod12.z.nativeEnum(AssigneeRole).optional(),
+  assignedTo: import_zod12.z.string().nullable().optional(),
+  dueDate: import_zod12.z.union([import_zod12.z.date(), import_zod12.z.number()]).nullable().optional(),
+  parentId: import_zod12.z.string().uuid().nullable().optional(),
+  sprintId: import_zod12.z.string().uuid().nullable().optional(),
+  acceptanceChecklist: import_zod12.z.array(AcceptanceItemSchema).optional(),
+  docIds: import_zod12.z.array(import_zod12.z.string().uuid()).optional()
+});
+var UpdateTaskSchema = TaskSchema.partial().omit({
+  id: true,
+  workspaceId: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({
+  title: import_zod12.z.string().min(1).max(200).optional(),
+  acceptanceChecklist: import_zod12.z.array(AcceptanceItemSchema).optional(),
+  docIds: import_zod12.z.array(import_zod12.z.string().uuid()).optional()
+});
+var AddCommentSchema = import_zod12.z.object({
+  author: import_zod12.z.string().min(1, "Author is required"),
+  text: import_zod12.z.string().min(1, "Comment text is required")
+});
+var DispatchTaskSchema = import_zod12.z.object({
+  workerId: import_zod12.z.string().optional(),
+  sprintId: import_zod12.z.string().uuid().optional().nullable()
+});
+var TaskIdParamSchema = import_zod12.z.object({
+  id: import_zod12.z.string().uuid("Invalid Task ID")
+});
+var TaskQuerySchema = import_zod12.z.object({});
+var TaskResponseSchema = import_zod12.z.object({
+  task: TaskSchema
+});
+var TasksResponseSchema = import_zod12.z.object({
+  tasks: import_zod12.z.array(TaskSchema)
+});
+// src/models/workspace.ts
+var import_zod13 = require("zod");
+var ChecklistItemSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  text: import_zod13.z.string(),
+  done: import_zod13.z.boolean()
+});
+var WorkspaceSchema = BaseEntitySchema.extend({
+  orgId: import_zod13.z.string().uuid(),
+  name: import_zod13.z.string().min(1, "Name is required").max(100),
+  defaultChecklist: import_zod13.z.array(ChecklistItemSchema).nullable().optional()
+});
+var CreateWorkspaceSchema = import_zod13.z.object({
+  name: import_zod13.z.string().min(1, "Name is required").max(100)
+});
+var UpdateWorkspaceSchema = WorkspaceSchema.partial().omit({
+  id: true,
+  orgId: true,
+  createdAt: true,
+  updatedAt: true
+});
+var AddWorkspaceMemberSchema = import_zod13.z.object({
+  userId: import_zod13.z.string().uuid("Invalid User ID"),
+  role: import_zod13.z.string().optional()
+});
+var WorkspaceIdParamSchema = import_zod13.z.object({
+  workspaceId: import_zod13.z.string().uuid("Invalid Workspace ID")
+});
+var WorkspaceAndUserParamSchema = import_zod13.z.object({
+  workspaceId: import_zod13.z.string().uuid("Invalid Workspace ID"),
+  userId: import_zod13.z.string().uuid("Invalid User ID")
+});
+var WorkspaceResponseSchema = import_zod13.z.object({
+  workspace: WorkspaceSchema
+});
+var WorkspacesResponseSchema = import_zod13.z.object({
+  workspaces: import_zod13.z.array(WorkspaceSchema)
+});
+var WorkspaceStatsSchema = import_zod13.z.object({
+  workspaceName: import_zod13.z.string(),
+  taskCounts: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.number()),
+  memberCount: import_zod13.z.number()
+});
+var WorkspaceStatsResponseSchema = import_zod13.z.object({
+  stats: WorkspaceStatsSchema
+});