@devpad/api 2.0.1 → 2.0.2

package/dist/schema/media.js

@@ -0,0 +1,776 @@
+import {
+  apiError,
+  authExpired,
+  badRequest,
+  configureErrorLogging,
+  conflict,
+  dbError,
+  encryptionError,
+  errors,
+  forbidden,
+  githubError,
+  isApiError,
+  isAuthExpiredError,
+  isBadRequestError,
+  isConflictError,
+  isDatabaseError,
+  isEncryptionError,
+  isForbiddenError,
+  isGithubError,
+  isNetworkError,
+  isNotFoundError,
+  isParseError,
+  isRateLimitedError,
+  isRetryableError,
+  isScanError,
+  isServiceError,
+  isStoreError,
+  isUnauthorizedError,
+  isValidationError,
+  networkError,
+  notFound,
+  parseError,
+  rateLimited,
+  scanError,
+  storeError,
+  unauthorized,
+  validation
+} from "../chunk-5X36WMYQ.js";
+import {
+  api_keys
+} from "../chunk-FOO5XXY5.js";
+
+// ../schema/dist/database/media.js
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { corpus_snapshots } from "@f0rbit/corpus/schema";
+var media_profiles = sqliteTable("media_profiles", {
+  id: text("id").primaryKey(),
+  user_id: text("user_id").notNull(),
+  slug: text("slug").notNull(),
+  name: text("name").notNull(),
+  description: text("description"),
+  theme: text("theme"),
+  created_at: text("created_at").notNull(),
+  updated_at: text("updated_at").notNull()
+}, (table) => ({
+  user_idx: index("idx_media_profiles_user").on(table.user_id),
+  user_slug_idx: uniqueIndex("idx_media_profiles_user_slug").on(table.user_id, table.slug)
+}));
+var media_accounts = sqliteTable("media_accounts", {
+  id: text("id").primaryKey(),
+  profile_id: text("profile_id").notNull().references(() => media_profiles.id, { onDelete: "cascade" }),
+  platform: text("platform").notNull().$type(),
+  platform_user_id: text("platform_user_id"),
+  platform_username: text("platform_username"),
+  access_token_encrypted: text("access_token_encrypted").notNull(),
+  refresh_token_encrypted: text("refresh_token_encrypted"),
+  token_expires_at: text("token_expires_at"),
+  is_active: integer("is_active", { mode: "boolean" }).default(true),
+  last_fetched_at: text("last_fetched_at"),
+  created_at: text("created_at").notNull(),
+  updated_at: text("updated_at").notNull()
+}, (table) => ({
+  profile_idx: index("idx_media_accounts_profile").on(table.profile_id),
+  profile_platform_user_idx: uniqueIndex("idx_media_accounts_profile_platform_user").on(table.profile_id, table.platform, table.platform_user_id)
+}));
+var media_rate_limits = sqliteTable("media_rate_limits", {
+  id: text("id").primaryKey(),
+  account_id: text("account_id").notNull().references(() => media_accounts.id),
+  remaining: integer("remaining"),
+  limit_total: integer("limit_total"),
+  reset_at: text("reset_at"),
+  consecutive_failures: integer("consecutive_failures").default(0),
+  last_failure_at: text("last_failure_at"),
+  circuit_open_until: text("circuit_open_until"),
+  updated_at: text("updated_at").notNull()
+}, (table) => ({
+  account_idx: uniqueIndex("idx_media_rate_limits_account").on(table.account_id)
+}));
+var media_account_settings = sqliteTable("media_account_settings", {
+  id: text("id").primaryKey(),
+  account_id: text("account_id").notNull().references(() => media_accounts.id, { onDelete: "cascade" }),
+  setting_key: text("setting_key").notNull(),
+  setting_value: text("setting_value").notNull(),
+  created_at: text("created_at").notNull(),
+  updated_at: text("updated_at").notNull()
+}, (table) => ({
+  account_key_idx: uniqueIndex("idx_media_account_settings_unique").on(table.account_id, table.setting_key),
+  account_idx: index("idx_media_account_settings_account").on(table.account_id)
+}));
+var media_profile_filters = sqliteTable("media_profile_filters", {
+  id: text("id").primaryKey(),
+  profile_id: text("profile_id").notNull().references(() => media_profiles.id, { onDelete: "cascade" }),
+  account_id: text("account_id").notNull().references(() => media_accounts.id, { onDelete: "cascade" }),
+  filter_type: text("filter_type").notNull().$type(),
+  filter_key: text("filter_key").notNull(),
+  filter_value: text("filter_value").notNull(),
+  created_at: text("created_at").notNull(),
+  updated_at: text("updated_at").notNull()
+}, (table) => ({
+  profile_idx: index("idx_media_profile_filters_profile").on(table.profile_id),
+  account_idx: index("idx_media_profile_filters_account").on(table.account_id)
+}));
+var media_platform_credentials = sqliteTable("media_platform_credentials", {
+  id: text("id").primaryKey(),
+  profile_id: text("profile_id").notNull().references(() => media_profiles.id, { onDelete: "cascade" }),
+  platform: text("platform").notNull().$type(),
+  client_id: text("client_id").notNull(),
+  client_secret_encrypted: text("client_secret_encrypted").notNull(),
+  redirect_uri: text("redirect_uri"),
+  metadata: text("metadata"),
+  is_verified: integer("is_verified", { mode: "boolean" }).default(false),
+  created_at: text("created_at").notNull(),
+  updated_at: text("updated_at").notNull()
+}, (table) => ({
+  profile_platform_idx: uniqueIndex("idx_platform_credentials_unique").on(table.profile_id, table.platform),
+  profile_idx: index("idx_platform_credentials_profile").on(table.profile_id)
+}));
+
+// ../schema/dist/media/branded.js
+var userId = (id) => id;
+var accountId = (id) => id;
+var profileId = (id) => id;
+var connectionId = (id) => id;
+var isValidId = (id) => typeof id === "string" && id.length > 0;
+
+// ../schema/dist/media/platforms/github.js
+import { z } from "zod";
+var GitHubRepoCommitSchema = z.object({
+  sha: z.string(),
+  message: z.string(),
+  author_name: z.string(),
+  author_email: z.string(),
+  author_date: z.string().datetime(),
+  committer_name: z.string(),
+  committer_email: z.string(),
+  committer_date: z.string().datetime(),
+  url: z.string().url(),
+  branch: z.string(),
+  additions: z.number().optional(),
+  deletions: z.number().optional(),
+  files_changed: z.number().optional()
+});
+var GitHubRepoCommitsStoreSchema = z.object({
+  owner: z.string(),
+  repo: z.string(),
+  branches: z.array(z.string()),
+  commits: z.array(GitHubRepoCommitSchema),
+  total_commits: z.number(),
+  fetched_at: z.string().datetime()
+});
+var GitHubRepoMetaSchema = z.object({
+  owner: z.string(),
+  name: z.string(),
+  full_name: z.string(),
+  default_branch: z.string(),
+  branches: z.array(z.string()),
+  is_private: z.boolean(),
+  pushed_at: z.string().datetime().nullable(),
+  updated_at: z.string().datetime()
+});
+var GitHubMetaStoreSchema = z.object({
+  username: z.string(),
+  repositories: z.array(GitHubRepoMetaSchema),
+  total_repos_available: z.number(),
+  repos_fetched: z.number(),
+  fetched_at: z.string().datetime()
+});
+var GitHubRepoPRSchema = z.object({
+  id: z.number(),
+  number: z.number(),
+  title: z.string(),
+  body: z.string().nullable(),
+  state: z.enum(["open", "closed", "merged"]),
+  url: z.string().url(),
+  created_at: z.string().datetime(),
+  updated_at: z.string().datetime(),
+  closed_at: z.string().datetime().nullable(),
+  merged_at: z.string().datetime().nullable(),
+  head_ref: z.string(),
+  base_ref: z.string(),
+  commit_shas: z.array(z.string()),
+  merge_commit_sha: z.string().nullable(),
+  author_login: z.string(),
+  author_avatar_url: z.string().url().optional(),
+  additions: z.number().optional(),
+  deletions: z.number().optional(),
+  changed_files: z.number().optional()
+});
+var GitHubRepoPRsStoreSchema = z.object({
+  owner: z.string(),
+  repo: z.string(),
+  pull_requests: z.array(GitHubRepoPRSchema),
+  total_prs: z.number(),
+  fetched_at: z.string().datetime()
+});
+
+// ../schema/dist/media/platforms/reddit.js
+import { z as z2 } from "zod";
+var RedditCommentSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  body: z2.string(),
+  body_html: z2.string().optional(),
+  permalink: z2.string(),
+  link_id: z2.string(),
+  link_title: z2.string(),
+  link_permalink: z2.string(),
+  subreddit: z2.string(),
+  subreddit_prefixed: z2.string(),
+  author: z2.string(),
+  created_utc: z2.number(),
+  score: z2.number(),
+  is_submitter: z2.boolean().default(false),
+  stickied: z2.boolean().default(false),
+  edited: z2.union([z2.boolean(), z2.number()]).default(false),
+  parent_id: z2.string()
+});
+var RedditCommentsStoreSchema = z2.object({
+  username: z2.string(),
+  comments: z2.array(RedditCommentSchema),
+  total_comments: z2.number(),
+  fetched_at: z2.string().datetime()
+});
+var RedditMetaStoreSchema = z2.object({
+  username: z2.string(),
+  user_id: z2.string(),
+  icon_img: z2.string().url().optional(),
+  total_karma: z2.number(),
+  link_karma: z2.number(),
+  comment_karma: z2.number(),
+  created_utc: z2.number(),
+  is_gold: z2.boolean().default(false),
+  subreddits_active: z2.array(z2.string()).default([]),
+  fetched_at: z2.string().datetime()
+});
+var RedditPostSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  title: z2.string(),
+  selftext: z2.string().default(""),
+  url: z2.string().url(),
+  permalink: z2.string(),
+  subreddit: z2.string(),
+  subreddit_prefixed: z2.string(),
+  author: z2.string(),
+  created_utc: z2.number(),
+  score: z2.number(),
+  upvote_ratio: z2.number().optional(),
+  num_comments: z2.number(),
+  is_self: z2.boolean(),
+  is_video: z2.boolean().default(false),
+  thumbnail: z2.string().optional(),
+  link_flair_text: z2.string().nullable().optional(),
+  over_18: z2.boolean().default(false),
+  spoiler: z2.boolean().default(false),
+  stickied: z2.boolean().default(false),
+  locked: z2.boolean().default(false),
+  archived: z2.boolean().default(false)
+});
+var RedditPostsStoreSchema = z2.object({
+  username: z2.string(),
+  posts: z2.array(RedditPostSchema),
+  total_posts: z2.number(),
+  fetched_at: z2.string().datetime()
+});
+
+// ../schema/dist/media/platforms/twitter.js
+import { z as z3 } from "zod";
+var TwitterUserMetricsSchema = z3.object({
+  followers_count: z3.number(),
+  following_count: z3.number(),
+  tweet_count: z3.number(),
+  listed_count: z3.number()
+});
+var TwitterMetaStoreSchema = z3.object({
+  id: z3.string(),
+  username: z3.string(),
+  name: z3.string(),
+  description: z3.string().optional(),
+  profile_image_url: z3.string().url().optional(),
+  profile_banner_url: z3.string().url().optional(),
+  url: z3.string().url().optional(),
+  location: z3.string().optional(),
+  created_at: z3.string().datetime(),
+  verified: z3.boolean().default(false),
+  verified_type: z3.enum(["blue", "business", "government", "none"]).default("none"),
+  protected: z3.boolean().default(false),
+  public_metrics: TwitterUserMetricsSchema,
+  pinned_tweet_id: z3.string().optional(),
+  fetched_at: z3.string().datetime()
+});
+var TweetMetricsSchema = z3.object({
+  retweet_count: z3.number().default(0),
+  reply_count: z3.number().default(0),
+  like_count: z3.number().default(0),
+  quote_count: z3.number().default(0),
+  impression_count: z3.number().optional(),
+  bookmark_count: z3.number().optional()
+});
+var TweetMediaSchema = z3.object({
+  media_key: z3.string(),
+  type: z3.enum(["photo", "video", "animated_gif"]),
+  url: z3.string().url().optional(),
+  preview_image_url: z3.string().url().optional(),
+  alt_text: z3.string().optional(),
+  duration_ms: z3.number().optional(),
+  width: z3.number().optional(),
+  height: z3.number().optional()
+});
+var TweetUrlSchema = z3.object({
+  start: z3.number(),
+  end: z3.number(),
+  url: z3.string(),
+  expanded_url: z3.string().optional(),
+  display_url: z3.string().optional(),
+  title: z3.string().optional(),
+  description: z3.string().optional()
+});
+var TwitterTweetSchema = z3.object({
+  id: z3.string(),
+  text: z3.string(),
+  created_at: z3.string().datetime(),
+  author_id: z3.string(),
+  conversation_id: z3.string().optional(),
+  in_reply_to_user_id: z3.string().optional(),
+  public_metrics: TweetMetricsSchema,
+  possibly_sensitive: z3.boolean().default(false),
+  lang: z3.string().optional(),
+  source: z3.string().optional(),
+  referenced_tweets: z3.array(z3.object({
+    type: z3.enum(["retweeted", "quoted", "replied_to"]),
+    id: z3.string()
+  })).optional(),
+  attachments: z3.object({
+    media_keys: z3.array(z3.string()).optional(),
+    poll_ids: z3.array(z3.string()).optional()
+  }).optional(),
+  entities: z3.object({
+    urls: z3.array(TweetUrlSchema).optional(),
+    mentions: z3.array(z3.object({
+      start: z3.number(),
+      end: z3.number(),
+      username: z3.string(),
+      id: z3.string()
+    })).optional(),
+    hashtags: z3.array(z3.object({
+      start: z3.number(),
+      end: z3.number(),
+      tag: z3.string()
+    })).optional()
+  }).optional()
+});
+var TwitterTweetsStoreSchema = z3.object({
+  user_id: z3.string(),
+  username: z3.string(),
+  tweets: z3.array(TwitterTweetSchema),
+  media: z3.array(TweetMediaSchema).default([]),
+  total_tweets: z3.number(),
+  oldest_tweet_id: z3.string().optional(),
+  newest_tweet_id: z3.string().optional(),
+  fetched_at: z3.string().datetime()
+});
+
+// ../schema/dist/media/platforms.js
+import { z as z4 } from "zod";
+var PLATFORMS = ["github", "bluesky", "youtube", "devpad", "reddit", "twitter"];
+var PlatformSchema = z4.enum(PLATFORMS);
+var MULTI_STORE_PLATFORMS = ["github", "reddit", "twitter"];
+var isMultiStorePlatform = (p) => MULTI_STORE_PLATFORMS.includes(p);
+var FetchedAtSchema = z4.object({
+  fetched_at: z4.string().datetime()
+});
+var GitHubRepoSchema = z4.object({
+  id: z4.number(),
+  name: z4.string(),
+  url: z4.string()
+});
+var GitHubBaseEventSchema = z4.object({
+  id: z4.string(),
+  type: z4.string(),
+  created_at: z4.string(),
+  repo: GitHubRepoSchema,
+  payload: z4.record(z4.unknown())
+});
+var GitHubEventSchema = GitHubBaseEventSchema;
+var GitHubExtendedCommitSchema = z4.object({
+  sha: z4.string(),
+  message: z4.string(),
+  date: z4.string(),
+  url: z4.string(),
+  repo: z4.string(),
+  branch: z4.string()
+});
+var GitHubPullRequestSchema = z4.object({
+  id: z4.number(),
+  number: z4.number(),
+  title: z4.string(),
+  state: z4.enum(["open", "closed", "merged"]),
+  action: z4.string(),
+  url: z4.string(),
+  repo: z4.string(),
+  created_at: z4.string(),
+  merged_at: z4.string().optional(),
+  head_ref: z4.string(),
+  base_ref: z4.string(),
+  commit_shas: z4.array(z4.string()).default([]),
+  merge_commit_sha: z4.string().optional()
+});
+var GitHubRawSchema = FetchedAtSchema.extend({
+  events: z4.array(GitHubEventSchema),
+  commits: z4.array(GitHubExtendedCommitSchema).default([]),
+  pull_requests: z4.array(GitHubPullRequestSchema).default([])
+});
+var BlueskyAuthorSchema = z4.object({
+  did: z4.string(),
+  handle: z4.string(),
+  displayName: z4.string().optional(),
+  avatar: z4.string().url().optional()
+});
+var BlueskyPostSchema = z4.object({
+  uri: z4.string(),
+  cid: z4.string(),
+  author: BlueskyAuthorSchema,
+  record: z4.object({
+    text: z4.string(),
+    createdAt: z4.string(),
+    reply: z4.object({
+      parent: z4.object({ uri: z4.string() }),
+      root: z4.object({ uri: z4.string() })
+    }).optional()
+  }),
+  replyCount: z4.number().default(0),
+  repostCount: z4.number().default(0),
+  likeCount: z4.number().default(0),
+  embed: z4.object({
+    images: z4.array(z4.object({
+      thumb: z4.string(),
+      fullsize: z4.string()
+    })).optional()
+  }).optional()
+});
+var BlueskyFeedItemSchema = z4.object({
+  post: BlueskyPostSchema,
+  reason: z4.object({
+    $type: z4.string(),
+    by: BlueskyAuthorSchema.optional()
+  }).optional()
+});
+var BlueskyRawSchema = FetchedAtSchema.extend({
+  feed: z4.array(BlueskyFeedItemSchema),
+  cursor: z4.string().optional()
+});
+var YouTubeThumbnailSchema = z4.object({
+  url: z4.string().url(),
+  width: z4.number().optional(),
+  height: z4.number().optional()
+});
+var YouTubeVideoSchema = z4.object({
+  kind: z4.string(),
+  etag: z4.string(),
+  id: z4.object({
+    kind: z4.string(),
+    videoId: z4.string()
+  }),
+  snippet: z4.object({
+    publishedAt: z4.string(),
+    channelId: z4.string(),
+    title: z4.string(),
+    description: z4.string(),
+    thumbnails: z4.object({
+      default: YouTubeThumbnailSchema.optional(),
+      medium: YouTubeThumbnailSchema.optional(),
+      high: YouTubeThumbnailSchema.optional()
+    }),
+    channelTitle: z4.string()
+  })
+});
+var YouTubeRawSchema = FetchedAtSchema.extend({
+  items: z4.array(YouTubeVideoSchema),
+  nextPageToken: z4.string().optional(),
+  pageInfo: z4.object({
+    totalResults: z4.number(),
+    resultsPerPage: z4.number()
+  }).optional()
+});
+var DevpadTaskSchema = z4.object({
+  id: z4.string(),
+  title: z4.string(),
+  status: z4.enum(["todo", "in_progress", "done", "archived"]),
+  priority: z4.enum(["low", "medium", "high"]).optional(),
+  project: z4.string().optional(),
+  tags: z4.array(z4.string()).default([]),
+  created_at: z4.string(),
+  updated_at: z4.string(),
+  due_date: z4.string().optional(),
+  completed_at: z4.string().optional()
+});
+var DevpadRawSchema = FetchedAtSchema.extend({
+  tasks: z4.array(DevpadTaskSchema)
+});
+
+// ../schema/dist/media/profiles.js
+import { z as z5 } from "zod";
+var slugRegex = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SlugSchema = z5.string().min(3, "Slug must be at least 3 characters").max(50, "Slug must be at most 50 characters").regex(slugRegex, "Slug must be lowercase alphanumeric with hyphens, no leading/trailing hyphens");
+var CreateProfileSchema = z5.object({
+  slug: SlugSchema,
+  name: z5.string().min(1, "Name is required").max(100, "Name must be at most 100 characters"),
+  description: z5.string().max(500, "Description must be at most 500 characters").optional(),
+  theme: z5.string().max(50).optional()
+});
+var UpdateProfileSchema = z5.object({
+  slug: SlugSchema.optional(),
+  name: z5.string().min(1).max(100).optional(),
+  description: z5.string().max(500).nullable().optional(),
+  theme: z5.string().max(50).nullable().optional()
+});
+var FilterTypeSchema = z5.enum(["include", "exclude"]);
+var FilterKeySchema = z5.enum(["repo", "subreddit", "keyword", "twitter_account"]);
+var AddFilterSchema = z5.object({
+  account_id: z5.string(),
+  filter_type: FilterTypeSchema,
+  filter_key: FilterKeySchema,
+  filter_value: z5.string().min(1, "Filter value is required").max(200, "Filter value too long")
+});
+
+// ../schema/dist/media/settings.js
+import { z as z6 } from "zod";
+var GitHubSettingsSchema = z6.object({
+  hidden_repos: z6.array(z6.string()).default([])
+});
+var BlueskySettingsSchema = z6.object({
+  include_replies: z6.boolean().default(true),
+  include_reposts: z6.boolean().default(false)
+});
+var YouTubeSettingsSchema = z6.object({
+  include_watch_history: z6.boolean().default(true),
+  include_liked: z6.boolean().default(false)
+});
+var DevpadSettingsSchema = z6.object({
+  hidden_projects: z6.array(z6.string()).default([])
+});
+var PlatformSettingsSchemaMap = {
+  github: GitHubSettingsSchema,
+  bluesky: BlueskySettingsSchema,
+  youtube: YouTubeSettingsSchema,
+  devpad: DevpadSettingsSchema
+};
+
+// ../schema/dist/media/timeline.js
+import { z as z7 } from "zod";
+var TimelineTypeSchema = z7.enum(["commit", "post", "video", "task", "pull_request", "comment"]);
+var CommitPayloadSchema = z7.object({
+  type: z7.literal("commit"),
+  sha: z7.string(),
+  message: z7.string(),
+  repo: z7.string(),
+  branch: z7.string(),
+  additions: z7.number().optional(),
+  deletions: z7.number().optional(),
+  files_changed: z7.number().optional()
+});
+var PostPayloadSchema = z7.object({
+  type: z7.literal("post"),
+  content: z7.string(),
+  author_handle: z7.string(),
+  author_name: z7.string().optional(),
+  author_avatar: z7.string().url().optional(),
+  reply_count: z7.number().default(0),
+  repost_count: z7.number().default(0),
+  like_count: z7.number().default(0),
+  has_media: z7.boolean().default(false),
+  is_reply: z7.boolean().default(false),
+  is_repost: z7.boolean().default(false),
+  subreddit: z7.string().optional()
+});
+var VideoPayloadSchema = z7.object({
+  type: z7.literal("video"),
+  channel_id: z7.string(),
+  channel_title: z7.string(),
+  description: z7.string().optional(),
+  thumbnail_url: z7.string().url().optional(),
+  duration: z7.string().optional(),
+  view_count: z7.number().optional(),
+  like_count: z7.number().optional()
+});
+var TaskPayloadSchema = z7.object({
+  type: z7.literal("task"),
+  status: z7.enum(["todo", "in_progress", "done", "archived"]),
+  priority: z7.enum(["low", "medium", "high"]).optional(),
+  project: z7.string().optional(),
+  tags: z7.array(z7.string()).default([]),
+  due_date: z7.string().datetime().optional(),
+  completed_at: z7.string().datetime().optional()
+});
+var PRCommitSchema = z7.object({
+  sha: z7.string(),
+  message: z7.string(),
+  url: z7.string()
+});
+var PullRequestPayloadSchema = z7.object({
+  type: z7.literal("pull_request"),
+  repo: z7.string(),
+  number: z7.number(),
+  title: z7.string(),
+  state: z7.enum(["open", "closed", "merged"]),
+  action: z7.string(),
+  head_ref: z7.string(),
+  base_ref: z7.string(),
+  additions: z7.number().optional(),
+  deletions: z7.number().optional(),
+  changed_files: z7.number().optional(),
+  commit_shas: z7.array(z7.string()).default([]),
+  merge_commit_sha: z7.string().nullable().optional(),
+  commits: z7.array(PRCommitSchema).default([])
+});
+var CommentPayloadSchema = z7.object({
+  type: z7.literal("comment"),
+  content: z7.string(),
+  author_handle: z7.string(),
+  parent_title: z7.string(),
+  parent_url: z7.string(),
+  subreddit: z7.string(),
+  score: z7.number(),
+  is_op: z7.boolean().default(false)
+});
+var PayloadSchema = z7.discriminatedUnion("type", [CommitPayloadSchema, PostPayloadSchema, VideoPayloadSchema, TaskPayloadSchema, PullRequestPayloadSchema, CommentPayloadSchema]);
+var TimelineItemSchema = z7.object({
+  id: z7.string(),
+  platform: PlatformSchema,
+  type: TimelineTypeSchema,
+  timestamp: z7.string().datetime(),
+  title: z7.string(),
+  url: z7.string().url(),
+  payload: PayloadSchema
+});
+var CommitGroupSchema = z7.object({
+  type: z7.literal("commit_group"),
+  repo: z7.string(),
+  branch: z7.string(),
+  date: z7.string(),
+  commits: z7.array(TimelineItemSchema),
+  total_additions: z7.number().default(0),
+  total_deletions: z7.number().default(0),
+  total_files_changed: z7.number().default(0)
+});
+var DateGroupSchema = z7.object({
+  date: z7.string(),
+  items: z7.array(z7.union([TimelineItemSchema, CommitGroupSchema]))
+});
+var TimelineSchema = z7.object({
+  user_id: z7.string(),
+  generated_at: z7.string().datetime(),
+  groups: z7.array(DateGroupSchema)
+});
+export {
+  AddFilterSchema,
+  BlueskyAuthorSchema,
+  BlueskyFeedItemSchema,
+  BlueskyPostSchema,
+  BlueskyRawSchema,
+  BlueskySettingsSchema,
+  CommentPayloadSchema,
+  CommitGroupSchema,
+  CommitPayloadSchema,
+  CreateProfileSchema,
+  DateGroupSchema,
+  DevpadRawSchema,
+  DevpadSettingsSchema,
+  DevpadTaskSchema,
+  FilterKeySchema,
+  FilterTypeSchema,
+  GitHubBaseEventSchema,
+  GitHubEventSchema,
+  GitHubExtendedCommitSchema,
+  GitHubMetaStoreSchema,
+  GitHubPullRequestSchema,
+  GitHubRawSchema,
+  GitHubRepoCommitSchema,
+  GitHubRepoCommitsStoreSchema,
+  GitHubRepoMetaSchema,
+  GitHubRepoPRSchema,
+  GitHubRepoPRsStoreSchema,
+  GitHubRepoSchema,
+  GitHubSettingsSchema,
+  MULTI_STORE_PLATFORMS,
+  PLATFORMS,
+  PayloadSchema,
+  PlatformSchema,
+  PlatformSettingsSchemaMap,
+  PostPayloadSchema,
+  PullRequestPayloadSchema,
+  RedditCommentSchema,
+  RedditCommentsStoreSchema,
+  RedditMetaStoreSchema,
+  RedditPostSchema,
+  RedditPostsStoreSchema,
+  SlugSchema,
+  TaskPayloadSchema,
+  TimelineItemSchema,
+  TimelineSchema,
+  TimelineTypeSchema,
+  TweetMediaSchema,
+  TweetMetricsSchema,
+  TweetUrlSchema,
+  TwitterMetaStoreSchema,
+  TwitterTweetSchema,
+  TwitterTweetsStoreSchema,
+  TwitterUserMetricsSchema,
+  UpdateProfileSchema,
+  VideoPayloadSchema,
+  YouTubeRawSchema,
+  YouTubeSettingsSchema,
+  YouTubeThumbnailSchema,
+  YouTubeVideoSchema,
+  accountId,
+  media_account_settings as accountSettings,
+  media_accounts as accounts,
+  apiError,
+  api_keys as apiKeys,
+  authExpired,
+  badRequest,
+  configureErrorLogging,
+  conflict,
+  connectionId,
+  corpus_snapshots,
+  dbError,
+  encryptionError,
+  errors,
+  forbidden,
+  githubError,
+  isApiError,
+  isAuthExpiredError,
+  isBadRequestError,
+  isConflictError,
+  isDatabaseError,
+  isEncryptionError,
+  isForbiddenError,
+  isGithubError,
+  isMultiStorePlatform,
+  isNetworkError,
+  isNotFoundError,
+  isParseError,
+  isRateLimitedError,
+  isRetryableError,
+  isScanError,
+  isServiceError,
+  isStoreError,
+  isUnauthorizedError,
+  isValidId,
+  isValidationError,
+  networkError,
+  notFound,
+  parseError,
+  media_platform_credentials as platformCredentials,
+  media_profile_filters as profileFilters,
+  profileId,
+  media_profiles as profiles,
+  rateLimited,
+  media_rate_limits as rateLimits,
+  scanError,
+  storeError,
+  unauthorized,
+  userId,
+  validation
+};