@devpad/api 2.0.0 → 2.0.2

package/dist/chunk-5X36WMYQ.js

@@ -0,0 +1,130 @@
+// ../schema/dist/errors.js
+import { err } from "@f0rbit/corpus";
+var defaultLogger = ({ error, context }) => {
+  console.error(`[${context.timestamp}] [${error.kind}]`, error.message || error.kind, { ...error, stack: context.stack?.split("\n").slice(2, 5).join("\n"), ...context });
+};
+var errorLogger = defaultLogger;
+var contextProvider = null;
+var configureErrorLogging = (config) => {
+  if (config.logger)
+    errorLogger = config.logger;
+  if (config.contextProvider)
+    contextProvider = config.contextProvider;
+};
+var logAndReturn = (error, ctx) => {
+  const context = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), stack: new Error().stack, ...contextProvider?.(), ...ctx };
+  errorLogger({ error, context });
+  return err(error);
+};
+var hasKind = (e, kind) => typeof e === "object" && e !== null && "kind" in e && e.kind === kind;
+var isNotFoundError = (e) => hasKind(e, "not_found");
+var isForbiddenError = (e) => hasKind(e, "forbidden");
+var isValidationError = (e) => hasKind(e, "validation");
+var isRateLimitedError = (e) => hasKind(e, "rate_limited");
+var isStoreError = (e) => hasKind(e, "store_error");
+var isNetworkError = (e) => hasKind(e, "network_error");
+var isAuthExpiredError = (e) => hasKind(e, "auth_expired");
+var isApiError = (e) => hasKind(e, "api_error");
+var isParseError = (e) => hasKind(e, "parse_error");
+var isEncryptionError = (e) => hasKind(e, "encryption_error");
+var isDatabaseError = (e) => hasKind(e, "db_error");
+var isConflictError = (e) => hasKind(e, "conflict");
+var isBadRequestError = (e) => hasKind(e, "bad_request");
+var isUnauthorizedError = (e) => hasKind(e, "unauthorized");
+var isScanError = (e) => hasKind(e, "scan_error");
+var isGithubError = (e) => hasKind(e, "github_error");
+var isServiceError = (e) => isNotFoundError(e) || isForbiddenError(e) || isValidationError(e) || isRateLimitedError(e) || isStoreError(e) || isNetworkError(e) || isAuthExpiredError(e) || isApiError(e) || isParseError(e) || isEncryptionError(e) || isDatabaseError(e) || isConflictError(e) || isBadRequestError(e) || isUnauthorizedError(e) || isScanError(e) || isGithubError(e);
+var isRetryableError = (e) => isRateLimitedError(e) || isNetworkError(e);
+var notFound = (resource, id, ctx) => logAndReturn({ kind: "not_found", resource, ...id && { id } }, ctx);
+var forbidden = (reason, ctx) => logAndReturn({ kind: "forbidden", ...reason && { reason, message: reason } }, ctx);
+var validation = (errors2, ctx) => logAndReturn({ kind: "validation", errors: errors2 }, ctx);
+var rateLimited = (retry_after, ctx) => logAndReturn({ kind: "rate_limited", ...retry_after !== void 0 && { retry_after } }, ctx);
+var storeError = (operation, message, ctx) => logAndReturn({ kind: "store_error", operation, ...message && { message } }, ctx);
+var networkError = (cause, message, ctx) => logAndReturn({ kind: "network_error", ...cause && { cause }, ...message && { message } }, ctx);
+var authExpired = (message, ctx) => logAndReturn({ kind: "auth_expired", ...message && { message } }, ctx);
+var apiError = (status, message, ctx) => logAndReturn({ kind: "api_error", status, ...message && { message } }, ctx);
+var parseError = (message, ctx) => logAndReturn({ kind: "parse_error", ...message && { message } }, ctx);
+var encryptionError = (operation, message, ctx) => logAndReturn({ kind: "encryption_error", operation, ...message && { message } }, ctx);
+var dbError = (message, ctx) => logAndReturn({ kind: "db_error", ...message && { message } }, ctx);
+var conflict = (resource, message, ctx) => logAndReturn({ kind: "conflict", ...resource && { resource }, ...message && { message } }, ctx);
+var badRequest = (message, details, ctx) => logAndReturn({ kind: "bad_request", ...message && { message }, ...details !== void 0 && { details } }, ctx);
+var unauthorized = (message, ctx) => logAndReturn({ kind: "unauthorized", ...message && { message } }, ctx);
+var scanError = (message, ctx) => logAndReturn({ kind: "scan_error", ...message && { message } }, ctx);
+var githubError = (message, ctx) => logAndReturn({ kind: "github_error", ...message && { message } }, ctx);
+var errors = {
+  notFound,
+  forbidden,
+  validation,
+  rateLimited,
+  storeError,
+  networkError,
+  authExpired,
+  apiError,
+  parseError,
+  encryptionError,
+  dbError,
+  conflict,
+  badRequest,
+  unauthorized,
+  scanError,
+  githubError,
+  is: {
+    notFound: isNotFoundError,
+    forbidden: isForbiddenError,
+    validation: isValidationError,
+    rateLimited: isRateLimitedError,
+    storeError: isStoreError,
+    networkError: isNetworkError,
+    authExpired: isAuthExpiredError,
+    apiError: isApiError,
+    parseError: isParseError,
+    encryptionError: isEncryptionError,
+    dbError: isDatabaseError,
+    conflict: isConflictError,
+    badRequest: isBadRequestError,
+    unauthorized: isUnauthorizedError,
+    scanError: isScanError,
+    githubError: isGithubError,
+    serviceError: isServiceError,
+    retryable: isRetryableError
+  }
+};
+
+export {
+  configureErrorLogging,
+  isNotFoundError,
+  isForbiddenError,
+  isValidationError,
+  isRateLimitedError,
+  isStoreError,
+  isNetworkError,
+  isAuthExpiredError,
+  isApiError,
+  isParseError,
+  isEncryptionError,
+  isDatabaseError,
+  isConflictError,
+  isBadRequestError,
+  isUnauthorizedError,
+  isScanError,
+  isGithubError,
+  isServiceError,
+  isRetryableError,
+  notFound,
+  forbidden,
+  validation,
+  rateLimited,
+  storeError,
+  networkError,
+  authExpired,
+  apiError,
+  parseError,
+  encryptionError,
+  dbError,
+  conflict,
+  badRequest,
+  unauthorized,
+  scanError,
+  githubError,
+  errors
+};

package/dist/chunk-FOO5XXY5.js

@@ -0,0 +1,318 @@
+// ../schema/dist/database/schema.js
+import { relations, sql } from "drizzle-orm";
+import { int, integer, primaryKey, sqliteTable, text, unique } from "drizzle-orm/sqlite-core";
+var timestamps = () => ({
+  created_at: text("created_at").notNull().default(sql`(CURRENT_TIMESTAMP)`),
+  updated_at: text("updated_at").notNull().default(sql`(CURRENT_TIMESTAMP)`)
+});
+var deleted = () => ({
+  deleted: int("deleted", { mode: "boolean" }).notNull().default(false)
+});
+var owner_id = () => ({
+  owner_id: text("owner_id").notNull().references(() => user.id)
+});
+var id = (prefix) => ({
+  id: text("id").primaryKey().$defaultFn(() => `${prefix}_${crypto.randomUUID()}`)
+});
+var entity = (prefix) => ({
+  ...id(prefix),
+  ...timestamps(),
+  ...deleted()
+});
+var owned_entity = (prefix) => ({
+  ...entity(prefix),
+  ...owner_id()
+});
+var user = sqliteTable("user", {
+  id: text("id").primaryKey().$defaultFn(() => `user_${crypto.randomUUID()}`),
+  github_id: integer("github_id"),
+  name: text("name"),
+  email: text("email").unique(),
+  email_verified: text("email_verified"),
+  // timestamp
+  image_url: text("image_url"),
+  task_view: text("task_view", { enum: ["list", "grid"] }).notNull().default("list")
+});
+var session = sqliteTable("session", {
+  id: text("id").notNull().primaryKey(),
+  userId: text("user_id").notNull().references(() => user.id),
+  expiresAt: integer("expires_at").notNull(),
+  access_token: text("access_token")
+});
+var api_keys = sqliteTable("api_keys", {
+  ...id("apikey"),
+  user_id: text("user_id").notNull().references(() => user.id),
+  key_hash: text("key_hash").notNull().unique(),
+  name: text("name"),
+  note: text("note"),
+  scope: text("scope", { enum: ["devpad", "blog", "media", "all"] }).notNull().default("all"),
+  enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+  last_used_at: text("last_used_at"),
+  ...timestamps(),
+  deleted: integer("deleted", { mode: "boolean" }).notNull().default(false)
+});
+var project = sqliteTable("project", {
+  ...owned_entity("project"),
+  project_id: text("project_id").notNull(),
+  name: text("name").notNull(),
+  description: text("description"),
+  specification: text("specification"),
+  repo_url: text("repo_url"),
+  repo_id: integer("repo_id"),
+  icon_url: text("icon_url"),
+  status: text("status", { enum: ["DEVELOPMENT", "PAUSED", "RELEASED", "LIVE", "FINISHED", "ABANDONED", "STOPPED"] }).notNull().default("DEVELOPMENT"),
+  link_url: text("link_url"),
+  link_text: text("link_text"),
+  visibility: text("visibility", { enum: ["PUBLIC", "PRIVATE", "HIDDEN", "ARCHIVED", "DRAFT", "DELETED"] }).notNull().default("PRIVATE"),
+  current_version: text("current_version"),
+  scan_branch: text("scan_branch")
+});
+var ACTIONS = [
+  "CREATE_TASK",
+  "UPDATE_TASK",
+  "DELETE_TASK",
+  "CREATE_PROJECT",
+  "UPDATE_PROJECT",
+  "DELETE_PROJECT",
+  "CREATE_TAG",
+  "UPDATE_TAG",
+  "DELETE_TAG",
+  "CREATE_GOAL",
+  "UPDATE_GOAL",
+  "DELETE_GOAL",
+  "CREATE_MILESTONE",
+  "UPDATE_MILESTONE",
+  "DELETE_MILESTONE",
+  "CREATE_CHECKLIST",
+  "UPDATE_CHECKLIST",
+  "DELETE_CHECKLIST"
+];
+var action = sqliteTable("action", {
+  ...owned_entity("action"),
+  type: text("type", { enum: ACTIONS }).notNull(),
+  description: text("description").notNull(),
+  data: text("data", { mode: "json" })
+});
+var tracker_result = sqliteTable("tracker_result", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  project_id: text("project_id").notNull().references(() => project.id),
+  created_at: text("created_at").notNull().default(sql`(CURRENT_TIMESTAMP)`),
+  data: text("data", { mode: "json" }).notNull(),
+  accepted: integer("accepted", { mode: "boolean" }).notNull().default(false)
+});
+var todo_updates = sqliteTable("todo_updates", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  project_id: text("project_id").notNull().references(() => project.id),
+  created_at: text("created_at").notNull().default(sql`(CURRENT_TIMESTAMP)`),
+  old_id: integer("old_id").references(() => tracker_result.id),
+  new_id: integer("new_id").notNull().references(() => tracker_result.id),
+  data: text("data", { mode: "json" }).notNull(),
+  status: text("status", { enum: ["PENDING", "ACCEPTED", "REJECTED", "IGNORED"] }).notNull().default("PENDING"),
+  branch: text("branch"),
+  commit_sha: text("commit_sha"),
+  commit_msg: text("commit_msg"),
+  commit_url: text("commit_url")
+});
+var update_tracker_relations = relations(todo_updates, ({ one }) => ({
+  old: one(tracker_result, { fields: [todo_updates.old_id], references: [tracker_result.id] }),
+  new: one(tracker_result, { fields: [todo_updates.new_id], references: [tracker_result.id] })
+}));
+var milestone = sqliteTable("milestone", {
+  ...entity("milestone"),
+  project_id: text("project_id").notNull().references(() => project.id),
+  name: text("name").notNull(),
+  description: text("description"),
+  target_time: text("target_time"),
+  target_version: text("target_version"),
+  finished_at: text("finished_at"),
+  after_id: text("after_id")
+});
+var goal = sqliteTable("goal", {
+  ...entity("goal"),
+  milestone_id: text("milestone_id").notNull().references(() => milestone.id),
+  name: text("name").notNull(),
+  description: text("description"),
+  target_time: text("target_time"),
+  finished_at: text("finished_at")
+});
+var task = sqliteTable("task", {
+  ...owned_entity("task"),
+  title: text("title").notNull(),
+  progress: text("progress", { enum: ["UNSTARTED", "IN_PROGRESS", "COMPLETED"] }).notNull().default("UNSTARTED"),
+  visibility: text("visibility", { enum: ["PUBLIC", "PRIVATE", "HIDDEN", "ARCHIVED", "DRAFT", "DELETED"] }).notNull().default("PRIVATE"),
+  goal_id: text("goal_id").references(() => goal.id),
+  project_id: text("project_id").references(() => project.id),
+  description: text("description"),
+  start_time: text("start_time"),
+  end_time: text("end_time"),
+  summary: text("summary"),
+  codebase_task_id: text("codebase_task_id").references(() => codebase_tasks.id),
+  priority: text("priority", { enum: ["LOW", "MEDIUM", "HIGH"] }).notNull().default("LOW")
+});
+var checklist = sqliteTable("checklist", {
+  ...entity("checklist"),
+  task_id: text("task_id").notNull().references(() => task.id),
+  name: text("name").notNull()
+});
+var checklist_item = sqliteTable("checklist_item", {
+  ...entity("checklist-item"),
+  checklist_id: text("checklist_id").notNull().references(() => checklist.id),
+  parent_id: text("parent_id"),
+  name: text("name").notNull(),
+  checked: int("checked", { mode: "boolean" }).notNull().default(false)
+});
+var codebase_tasks = sqliteTable("codebase_tasks", {
+  ...entity("codebase-task"),
+  branch: text("branch"),
+  commit_sha: text("commit_sha"),
+  commit_msg: text("commit_msg"),
+  commit_url: text("commit_url"),
+  type: text("type"),
+  text: text("text"),
+  file: text("file"),
+  line: integer("line"),
+  context: text("context", { mode: "json" }),
+  recent_scan_id: integer("recent_scan_id").references(() => tracker_result.id)
+});
+var tag = sqliteTable("tag", {
+  ...owned_entity("tag"),
+  title: text("title").notNull(),
+  color: text("color"),
+  render: int("render", { mode: "boolean" }).notNull().default(true)
+}, (table) => ({
+  tag_unique: unique("tag_unique").on(table.owner_id, table.title)
+}));
+var task_tag = sqliteTable("task_tag", {
+  task_id: text("task_id").notNull().references(() => task.id),
+  tag_id: text("tag_id").notNull().references(() => tag.id),
+  ...timestamps()
+}, (table) => ({
+  task_tag_unique: primaryKey({ columns: [table.task_id, table.tag_id] })
+}));
+var commit_detail = sqliteTable("commit_detail", {
+  sha: text("sha").primaryKey(),
+  message: text("message").notNull(),
+  url: text("url").notNull(),
+  avatar_url: text("avatar_url"),
+  author_user: text("author_user").notNull(),
+  author_name: text("author_name"),
+  author_email: text("author_email").notNull(),
+  date: text("date").notNull()
+});
+var tag_config = sqliteTable("tag_config", {
+  ...id("tag_config"),
+  project_id: text("project_id").notNull().references(() => project.id),
+  // Foreign key to projects
+  tag_id: text("tag_id").notNull().references(() => tag.id),
+  // Foreign key to tags
+  match: text("match").notNull(),
+  // Match pattern for this tag
+  ...timestamps()
+});
+var ignore_path = sqliteTable("ignore_path", {
+  ...id("ignore_path"),
+  project_id: text("project_id").notNull().references(() => project.id),
+  // Foreign key to projects
+  path: text("path").notNull(),
+  // Ignore path
+  ...timestamps()
+});
+var user_relations = relations(user, ({ many }) => ({
+  sessions: many(session),
+  api_keys: many(api_keys),
+  actions: many(action),
+  tasks: many(task),
+  tags: many(tag)
+}));
+var session_relations = relations(session, ({ one }) => ({
+  user: one(user, { fields: [session.userId], references: [user.id] })
+}));
+var api_keys_relations = relations(api_keys, ({ one }) => ({
+  owner: one(user, { fields: [api_keys.user_id], references: [user.id] })
+}));
+var project_relations = relations(project, ({ one, many }) => ({
+  owner: one(user, { fields: [project.owner_id], references: [user.id] }),
+  tracker_results: many(tracker_result),
+  milestones: many(milestone),
+  todo_updates: many(todo_updates)
+}));
+var action_relations = relations(action, ({ one }) => ({
+  owner: one(user, { fields: [action.owner_id], references: [user.id] })
+}));
+var tracker_result_relations = relations(tracker_result, ({ one }) => ({
+  project: one(project, { fields: [tracker_result.project_id], references: [project.id] })
+}));
+var todoUpdatesRelations = relations(todo_updates, ({ one }) => ({
+  project: one(project, { fields: [todo_updates.project_id], references: [project.id] }),
+  oldTrackerResult: one(tracker_result, { fields: [todo_updates.old_id], references: [tracker_result.id] }),
+  newTrackerResult: one(tracker_result, { fields: [todo_updates.new_id], references: [tracker_result.id] })
+}));
+var milestone_relations = relations(milestone, ({ one, many }) => ({
+  project: one(project, { fields: [milestone.project_id], references: [project.id] }),
+  goals: many(goal)
+}));
+var goal_relations = relations(goal, ({ one }) => ({
+  milestone: one(milestone, { fields: [goal.milestone_id], references: [milestone.id] })
+}));
+var task_relations = relations(task, ({ one, many }) => ({
+  owner: one(user, { fields: [task.owner_id], references: [user.id] }),
+  goal: one(goal, { fields: [task.goal_id], references: [goal.id] }),
+  codebase_task: one(codebase_tasks, { fields: [task.codebase_task_id], references: [codebase_tasks.id] }),
+  checklists: many(checklist)
+}));
+var checklist_relations = relations(checklist, ({ one, many }) => ({
+  task: one(task, { fields: [checklist.task_id], references: [task.id] }),
+  items: many(checklist_item)
+}));
+var checklist_item_relations = relations(checklist_item, ({ one }) => ({
+  checklist: one(checklist, { fields: [checklist_item.checklist_id], references: [checklist.id] })
+}));
+var tag_relations = relations(tag, ({ one }) => ({
+  owner: one(user, { fields: [tag.owner_id], references: [user.id] })
+}));
+var task_tag_relations = relations(task_tag, ({ one }) => ({
+  task: one(task, { fields: [task_tag.task_id], references: [task.id] }),
+  tag: one(tag, { fields: [task_tag.tag_id], references: [tag.id] })
+}));
+
+export {
+  timestamps,
+  deleted,
+  owner_id,
+  id,
+  entity,
+  owned_entity,
+  user,
+  session,
+  api_keys,
+  project,
+  action,
+  tracker_result,
+  todo_updates,
+  update_tracker_relations,
+  milestone,
+  goal,
+  task,
+  checklist,
+  checklist_item,
+  codebase_tasks,
+  tag,
+  task_tag,
+  commit_detail,
+  tag_config,
+  ignore_path,
+  user_relations,
+  session_relations,
+  api_keys_relations,
+  project_relations,
+  action_relations,
+  tracker_result_relations,
+  todoUpdatesRelations,
+  milestone_relations,
+  goal_relations,
+  task_relations,
+  checklist_relations,
+  checklist_item_relations,
+  tag_relations,
+  task_tag_relations
+};

package/dist/chunk-WTGVONUB.js

@@ -0,0 +1,166 @@
+// ../schema/dist/types.js
+var TAG_COLOURS = {
+  red: { colour: "#F28B82", text: "#faeeef", border: "#F5A5A5" },
+  green: { colour: "#CCFF90", text: "#2E7D32", border: "#A5D6A7" },
+  blue: { colour: "#82B1FF", text: "#0D47A1", border: "#90CAF9" },
+  yellow: { colour: "#FFF176", text: "#F57F17", border: "#FFF59D" },
+  purple: { colour: "#E1BEE7", text: "#4A148C", border: "#CE93D8" },
+  orange: { colour: "#FFCC80", text: "#E65100", border: "#FFB74D" },
+  teal: { colour: "#80CBC4", text: "#004D40", border: "#4DB6AC" },
+  pink: { colour: "#F8BBD9", text: "#880E4F", border: "#F48FB1" },
+  gray: { colour: "#CFD8DC", text: "#37474F", border: "#B0BEC5" },
+  cyan: { colour: "#84FFFF", text: "#006064", border: "#4DD0E1" },
+  lime: { colour: "#ddf0bc", text: "#88b47f", border: "#becca5" }
+};
+var ArrayBufferedQueue = class {
+  constructor(_capacity) {
+    this._capacity = _capacity;
+    this._entries = [];
+    this._head = 0;
+    this._tail = 0;
+    this._size = 0;
+  }
+  latest() {
+    if (this._size === 0)
+      return null;
+    return this._entries[this._tail - 1] ?? null;
+  }
+  list() {
+    if (this._size === 0)
+      return [];
+    if (this._head < this._tail) {
+      return this._entries.slice(this._head, this._tail);
+    }
+    return this._entries.slice(this._head).concat(this._entries.slice(0, this._tail));
+  }
+  add(item) {
+    if (this._size === this._capacity) {
+      this._head = (this._head + 1) % this._capacity;
+    } else {
+      this._size++;
+    }
+    this._entries[this._tail] = item;
+    this._tail = (this._tail + 1) % this._capacity;
+  }
+  size() {
+    return this._size;
+  }
+  clear() {
+    this._entries = [];
+    this._head = 0;
+    this._tail = 0;
+    this._size = 0;
+  }
+};
+
+// ../schema/dist/validation.js
+import { z } from "zod";
+var upsert_project = z.object({
+  id: z.string().optional().nullable(),
+  project_id: z.string(),
+  owner_id: z.string().optional(),
+  name: z.string(),
+  description: z.string().nullable(),
+  specification: z.string().nullable(),
+  repo_url: z.string().nullable(),
+  repo_id: z.number().nullable(),
+  icon_url: z.string().nullable(),
+  status: z.union([z.literal("DEVELOPMENT"), z.literal("PAUSED"), z.literal("RELEASED"), z.literal("LIVE"), z.literal("FINISHED"), z.literal("ABANDONED"), z.literal("STOPPED")]).optional(),
+  deleted: z.boolean().optional().default(false),
+  link_url: z.string().nullable(),
+  link_text: z.string().nullable(),
+  visibility: z.union([z.literal("PUBLIC"), z.literal("PRIVATE"), z.literal("HIDDEN"), z.literal("ARCHIVED"), z.literal("DRAFT"), z.literal("DELETED")]).optional(),
+  current_version: z.string().nullable()
+});
+var upsert_todo = z.object({
+  id: z.string().optional().nullable(),
+  title: z.string().optional(),
+  summary: z.string().optional().nullable(),
+  description: z.string().optional().nullable(),
+  progress: z.union([z.literal("UNSTARTED"), z.literal("IN_PROGRESS"), z.literal("COMPLETED")]).optional(),
+  visibility: z.union([z.literal("PUBLIC"), z.literal("PRIVATE"), z.literal("HIDDEN"), z.literal("ARCHIVED"), z.literal("DRAFT"), z.literal("DELETED")]).optional(),
+  start_time: z.string().optional().nullable(),
+  end_time: z.string().optional().nullable(),
+  priority: z.union([z.literal("LOW"), z.literal("MEDIUM"), z.literal("HIGH")]).optional(),
+  owner_id: z.string(),
+  project_id: z.string().optional().nullable(),
+  goal_id: z.string().optional().nullable()
+});
+var update_action = z.union([z.literal("CONFIRM"), z.literal("UNLINK"), z.literal("CREATE"), z.literal("IGNORE"), z.literal("DELETE"), z.literal("COMPLETE")]);
+var ConfigSchema = z.object({
+  tags: z.array(z.object({
+    name: z.string(),
+    match: z.array(z.string())
+  })),
+  ignore: z.array(z.string().regex(/^[^]*$/, "Invalid path"))
+});
+var upsert_tag = z.object({
+  id: z.string().optional(),
+  title: z.string(),
+  color: z.union([z.literal("red"), z.literal("green"), z.literal("blue"), z.literal("yellow"), z.literal("purple"), z.literal("orange"), z.literal("teal"), z.literal("pink"), z.literal("gray"), z.literal("cyan"), z.literal("lime")]).nullable().optional(),
+  deleted: z.boolean().optional().default(false),
+  render: z.boolean().optional().default(true),
+  owner_id: z.string()
+});
+var project_config = z.object({
+  tags: z.array(z.object({
+    name: z.string(),
+    match: z.array(z.string())
+  })),
+  ignore: z.array(z.string())
+});
+var save_config_request = z.object({
+  id: z.string(),
+  config: project_config,
+  scan_branch: z.string().optional()
+});
+var save_tags_request = z.array(upsert_tag);
+var update_user = z.object({
+  id: z.string(),
+  name: z.string().optional(),
+  image_url: z.string().optional(),
+  task_view: z.union([z.literal("list"), z.literal("grid")]).optional(),
+  email_verified: z.boolean().optional()
+});
+var config_schema = z.object({
+  tags: z.array(z.object({
+    name: z.string(),
+    match: z.array(z.string())
+  })),
+  ignore: z.array(z.string().regex(/^[^]*$/, "Invalid path"))
+});
+var upsert_milestone = z.object({
+  id: z.string().optional().nullable(),
+  project_id: z.string(),
+  name: z.string().min(1).max(200),
+  description: z.string().nullable().optional(),
+  target_time: z.string().nullable().optional(),
+  target_version: z.string().nullable().optional(),
+  finished_at: z.string().nullable().optional(),
+  after_id: z.string().nullable().optional()
+});
+var upsert_goal = z.object({
+  id: z.string().optional().nullable(),
+  milestone_id: z.string(),
+  name: z.string().min(1).max(200),
+  description: z.string().nullable().optional(),
+  target_time: z.string().nullable().optional(),
+  finished_at: z.string().nullable().optional()
+});
+
+export {
+  TAG_COLOURS,
+  ArrayBufferedQueue,
+  upsert_project,
+  upsert_todo,
+  update_action,
+  ConfigSchema,
+  upsert_tag,
+  project_config,
+  save_config_request,
+  save_tags_request,
+  update_user,
+  config_schema,
+  upsert_milestone,
+  upsert_goal
+};