@hexclave/shared 1.0.3 → 1.0.5

package/src/interface/conversations.ts

@@ -0,0 +1,109 @@
+import * as yup from "yup";
+import { yupArray, yupBoolean, yupMixed, yupObject, yupString } from "../schema-fields";
+
+export const conversationStatusValues = ["open", "pending", "closed"] as const;
+export type ConversationStatus = (typeof conversationStatusValues)[number];
+
+export const conversationPriorityValues = ["low", "normal", "high", "urgent"] as const;
+export type ConversationPriority = (typeof conversationPriorityValues)[number];
+
+export const conversationSourceValues = ["manual", "chat", "email", "api"] as const;
+export type ConversationSource = (typeof conversationSourceValues)[number];
+
+export const conversationSenderTypeValues = ["user", "agent", "system"] as const;
+export type ConversationSenderType = (typeof conversationSenderTypeValues)[number];
+
+export const conversationMessageTypeValues = ["message", "internal-note", "status-change"] as const;
+export type ConversationMessageType = (typeof conversationMessageTypeValues)[number];
+
+export const conversationMetadataSchema = yupObject({
+  assignedToUserId: yupString().nullable().defined(),
+  assignedToDisplayName: yupString().nullable().defined(),
+  tags: yupArray(yupString().defined()).defined(),
+  firstResponseDueAt: yupString().nullable().defined(),
+  firstResponseAt: yupString().nullable().defined(),
+  nextResponseDueAt: yupString().nullable().defined(),
+  lastCustomerReplyAt: yupString().nullable().defined(),
+  lastAgentReplyAt: yupString().nullable().defined(),
+});
+
+export const conversationSenderSchema = yupObject({
+  type: yupString().oneOf(conversationSenderTypeValues).defined(),
+  id: yupString().nullable().defined(),
+  displayName: yupString().nullable().defined(),
+  primaryEmail: yupString().nullable().defined(),
+});
+
+export const conversationSummarySchema = yupObject({
+  conversationId: yupString().uuid().defined(),
+  userId: yupString().uuid().nullable().defined(),
+  teamId: yupString().uuid().nullable().defined(),
+  userDisplayName: yupString().nullable().defined(),
+  userPrimaryEmail: yupString().nullable().defined(),
+  userProfileImageUrl: yupString().nullable().defined(),
+  subject: yupString().defined(),
+  status: yupString().oneOf(conversationStatusValues).defined(),
+  priority: yupString().oneOf(conversationPriorityValues).defined(),
+  source: yupString().oneOf(conversationSourceValues).defined(),
+  lastMessageType: yupString().oneOf(conversationMessageTypeValues).defined(),
+  preview: yupString().nullable().defined(),
+  lastActivityAt: yupString().defined(),
+  metadata: conversationMetadataSchema.defined(),
+  createdAt: yupString().optional(),
+  updatedAt: yupString().optional(),
+  lastMessageAt: yupString().optional(),
+  lastInboundAt: yupString().nullable().optional(),
+  lastOutboundAt: yupString().nullable().optional(),
+  closedAt: yupString().nullable().optional(),
+  recordMetadata: yupMixed().nullable().optional(),
+});
+
+export const conversationEntryPointSchema = yupObject({
+  id: yupString().uuid().defined(),
+  channelType: yupString().defined(),
+  adapterKey: yupString().defined(),
+  externalChannelId: yupString().nullable().defined(),
+  isEntryPoint: yupBoolean().defined(),
+  metadata: yupMixed().nullable().defined(),
+  createdAt: yupString().defined(),
+  updatedAt: yupString().defined(),
+});
+
+// Message detail responses include parent conversation context for clients.
+// `subject`, `status`, `priority`, and `source` are populated from the parent
+// Conversation by the backend mapper; they are not stored on ConversationMessage.
+export const conversationMessageSchema = yupObject({
+  id: yupString().uuid().defined(),
+  conversationId: yupString().uuid().defined(),
+  userId: yupString().uuid().nullable().defined(),
+  teamId: yupString().uuid().nullable().defined(),
+  subject: yupString().defined(),
+  status: yupString().oneOf(conversationStatusValues).defined(),
+  priority: yupString().oneOf(conversationPriorityValues).defined(),
+  source: yupString().oneOf(conversationSourceValues).defined(),
+  messageType: yupString().oneOf(conversationMessageTypeValues).defined(),
+  body: yupString().nullable().defined(),
+  attachments: yupArray(yupMixed().defined()).defined(),
+  metadata: yupMixed().nullable().defined(),
+  createdAt: yupString().defined(),
+  sender: conversationSenderSchema.defined(),
+});
+
+export const conversationListResponseSchema = yupObject({
+  conversations: yupArray(conversationSummarySchema.defined()).defined(),
+  hasMore: yupBoolean().defined(),
+});
+
+export const conversationDetailResponseSchema = yupObject({
+  conversation: conversationSummarySchema.defined(),
+  messages: yupArray(conversationMessageSchema.defined()).defined(),
+  entryPoints: yupArray(conversationEntryPointSchema.defined()).defined(),
+});
+
+export type ConversationMetadata = yup.InferType<typeof conversationMetadataSchema>;
+export type ConversationSender = yup.InferType<typeof conversationSenderSchema>;
+export type ConversationSummary = yup.InferType<typeof conversationSummarySchema>;
+export type ConversationMessage = yup.InferType<typeof conversationMessageSchema>;
+export type ConversationListResponse = yup.InferType<typeof conversationListResponseSchema>;
+export type ConversationEntryPoint = yup.InferType<typeof conversationEntryPointSchema>;
+export type ConversationDetailResponse = yup.InferType<typeof conversationDetailResponseSchema>;

package/src/interface/crud/analytics.ts

@@ -0,0 +1,11 @@
+export type AnalyticsQueryOptions = {
+  query: string,
+  params?: Record<string, unknown>,
+  timeout_ms?: number,
+  include_all_branches?: boolean,
+};
+
+export type AnalyticsQueryResponse = {
+  result: Record<string, unknown>[],
+  query_id: string,
+};

package/src/interface/crud/connected-accounts.ts

@@ -0,0 +1,52 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import {
+  oauthProviderAccountIdSchema,
+  oauthProviderProviderConfigIdSchema,
+  userIdOrMeSchema,
+  yupObject,
+  yupString
+} from "../../schema-fields";
+
+// Connected Account CRUD (for listing/reading connected accounts)
+export const connectedAccountClientReadSchema = yupObject({
+  user_id: userIdOrMeSchema.defined(),
+  provider: oauthProviderProviderConfigIdSchema.defined(),
+  provider_account_id: oauthProviderAccountIdSchema.defined(),
+}).defined();
+
+export const connectedAccountCrud = createCrud({
+  clientReadSchema: connectedAccountClientReadSchema,
+  docs: {
+    clientRead: {
+      summary: "Get a connected account",
+      description: "Retrieves a specific connected account by the user ID and provider account ID.",
+      tags: ["Connected Accounts"],
+    },
+    clientList: {
+      summary: "List connected accounts",
+      description: "Retrieves a list of all connected accounts for a user.",
+      tags: ["Connected Accounts"],
+    },
+  },
+});
+export type ConnectedAccountCrud = CrudTypeOf<typeof connectedAccountCrud>;
+
+// Connected Account Access Token CRUD (for getting access tokens)
+export const connectedAccountAccessTokenReadSchema = yupObject({
+  access_token: yupString().defined(),
+}).defined();
+
+export const connectedAccountAccessTokenCreateSchema = yupObject({
+  scope: yupString().optional(),
+}).defined();
+
+export const connectedAccountAccessTokenCrud = createCrud({
+  clientReadSchema: connectedAccountAccessTokenReadSchema,
+  clientCreateSchema: connectedAccountAccessTokenCreateSchema,
+  docs: {
+    clientCreate: {
+      hidden: true,
+    }
+  },
+});
+export type ConnectedAccountAccessTokenCrud = CrudTypeOf<typeof connectedAccountAccessTokenCrud>;

package/src/interface/crud/contact-channels.ts

@@ -0,0 +1,74 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import { contactChannelIdSchema, contactChannelIsPrimarySchema, contactChannelIsVerifiedSchema, contactChannelTypeSchema, contactChannelUsedForAuthSchema, contactChannelValueSchema, userIdOrMeSchema, userIdSchema, yupMixed, yupObject } from "../../schema-fields";
+
+export const contactChannelsClientReadSchema = yupObject({
+  user_id: userIdSchema.defined(),
+  id: contactChannelIdSchema.defined(),
+  value: contactChannelValueSchema.defined(),
+  type: contactChannelTypeSchema.defined(),
+  used_for_auth: contactChannelUsedForAuthSchema.defined(),
+  is_verified: contactChannelIsVerifiedSchema.defined(),
+  is_primary: contactChannelIsPrimarySchema.defined(),
+}).defined();
+
+export const contactChannelsCrudClientUpdateSchema = yupObject({
+  value: contactChannelValueSchema.optional(),
+  type: contactChannelTypeSchema.optional(),
+  used_for_auth: contactChannelUsedForAuthSchema.optional(),
+  is_primary: contactChannelIsPrimarySchema.optional(),
+}).defined();
+
+export const contactChannelsCrudServerUpdateSchema = contactChannelsCrudClientUpdateSchema.concat(yupObject({
+  is_verified: contactChannelIsVerifiedSchema.optional(),
+}));
+
+export const contactChannelsCrudClientCreateSchema = yupObject({
+  user_id: userIdOrMeSchema.defined(),
+  value: contactChannelValueSchema.defined(),
+  type: contactChannelTypeSchema.defined(),
+  used_for_auth: contactChannelUsedForAuthSchema.defined(),
+  is_primary: contactChannelIsPrimarySchema.optional(),
+}).defined();
+
+export const contactChannelsCrudServerCreateSchema = contactChannelsCrudClientCreateSchema.concat(yupObject({
+  is_verified: contactChannelIsVerifiedSchema.optional(),
+}));
+
+export const contactChannelsCrudClientDeleteSchema = yupMixed();
+
+export const contactChannelsCrud = createCrud({
+  clientReadSchema: contactChannelsClientReadSchema,
+  clientUpdateSchema: contactChannelsCrudClientUpdateSchema,
+  clientCreateSchema: contactChannelsCrudClientCreateSchema,
+  clientDeleteSchema: contactChannelsCrudClientDeleteSchema,
+  serverUpdateSchema: contactChannelsCrudServerUpdateSchema,
+  serverCreateSchema: contactChannelsCrudServerCreateSchema,
+  docs: {
+    clientRead: {
+      summary: "Get a contact channel",
+      description: "Retrieves a specific contact channel by the user ID and the contact channel ID.",
+      tags: ["Contact Channels"],
+    },
+    clientCreate: {
+      summary: "Create a contact channel",
+      description: "Add a new contact channel for a user.",
+      tags: ["Contact Channels"],
+    },
+    clientUpdate: {
+      summary: "Update a contact channel",
+      description: "Updates an existing contact channel. Only the values provided will be updated.",
+      tags: ["Contact Channels"],
+    },
+    clientDelete: {
+      summary: "Delete a contact channel",
+      description: "Removes a contact channel for a given user.",
+      tags: ["Contact Channels"],
+    },
+    clientList: {
+      summary: "List contact channels",
+      description: "Retrieves a list of all contact channels for a user.",
+      tags: ["Contact Channels"],
+    }
+  }
+});
+export type ContactChannelsCrud = CrudTypeOf<typeof contactChannelsCrud>;

package/src/interface/crud/current-user.ts

@@ -0,0 +1,72 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import { yupObject } from "../../schema-fields";
+import { teamsCrudClientReadSchema } from "./teams";
+import { usersCrudServerDeleteSchema, usersCrudServerReadSchema, usersCrudServerUpdateSchema } from "./users";
+
+const clientUpdateSchema = usersCrudServerUpdateSchema.pick([
+  "display_name",
+  "profile_image_url",
+  "client_metadata",
+  "selected_team_id",
+  "totp_secret_base64",
+  "otp_auth_enabled",
+  "passkey_auth_enabled",
+  "primary_email",
+]).defined();
+
+const serverUpdateSchema = usersCrudServerUpdateSchema;
+
+const clientReadSchema = usersCrudServerReadSchema.pick([
+  "id",
+  "primary_email",
+  "primary_email_verified",
+  "display_name",
+  "client_metadata",
+  "client_read_only_metadata",
+  "profile_image_url",
+  "signed_up_at_millis",
+  "has_password",
+  "auth_with_email",
+  "oauth_providers",
+  "selected_team_id",
+  "requires_totp_mfa",
+  "otp_auth_enabled",
+  "passkey_auth_enabled",
+  "is_anonymous",
+  "is_restricted",
+  "restricted_reason",
+  "restricted_by_admin",
+  "restricted_by_admin_reason",
+]).concat(yupObject({
+  selected_team: teamsCrudClientReadSchema.nullable().defined(),
+})).defined();
+
+const serverReadSchema = usersCrudServerReadSchema.defined();
+
+const clientDeleteSchema = usersCrudServerDeleteSchema;
+
+export const currentUserCrud = createCrud({
+  clientReadSchema,
+  serverReadSchema,
+  clientUpdateSchema,
+  serverUpdateSchema,
+  clientDeleteSchema,
+  docs: {
+    clientRead: {
+      summary: 'Get current user',
+      description: 'Gets the currently authenticated user.',
+      tags: ['Users'],
+    },
+    clientUpdate: {
+      summary: 'Update current user',
+      description: 'Updates the currently authenticated user. Only the values provided will be updated.',
+      tags: ['Users'],
+    },
+    clientDelete: {
+      summary: 'Delete current user',
+      description: 'Deletes the currently authenticated user. Use this with caution.',
+      tags: ['Users'],
+    },
+  },
+});
+export type CurrentUserCrud = CrudTypeOf<typeof currentUserCrud>;

package/src/interface/crud/email-outbox.ts

@@ -0,0 +1,263 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import * as fieldSchema from "../../schema-fields";
+
+
+// Recipient types
+const recipientUserPrimaryEmailSchema = fieldSchema.yupObject({
+  type: fieldSchema.yupString().oneOf(["user-primary-email"]).defined(),
+  user_id: fieldSchema.yupString().defined(),
+}).defined();
+
+const recipientUserCustomEmailsSchema = fieldSchema.yupObject({
+  type: fieldSchema.yupString().oneOf(["user-custom-emails"]).defined(),
+  user_id: fieldSchema.yupString().defined(),
+  emails: fieldSchema.yupArray(fieldSchema.yupString().defined()).defined(),
+}).defined();
+
+const recipientCustomEmailsSchema = fieldSchema.yupObject({
+  type: fieldSchema.yupString().oneOf(["custom-emails"]).defined(),
+  emails: fieldSchema.yupArray(fieldSchema.yupString().defined()).defined(),
+}).defined();
+
+const recipientSchema = fieldSchema.yupUnion(
+  recipientUserPrimaryEmailSchema,
+  recipientUserCustomEmailsSchema,
+  recipientCustomEmailsSchema
+);
+
+
+// =============================== BASE FIELDS ===============================
+
+// Base fields present on all emails
+const emailOutboxBaseSchema = fieldSchema.yupObject({
+  id: fieldSchema.yupString().defined(),
+  created_at_millis: fieldSchema.yupNumber().defined(),
+  updated_at_millis: fieldSchema.yupNumber().defined(),
+  tsx_source: fieldSchema.yupString().defined(),
+  theme_id: fieldSchema.yupString().nullable().defined(),
+  to: recipientSchema.defined(),
+  variables: fieldSchema.yupRecord(fieldSchema.yupString(), fieldSchema.jsonSchema).defined(),
+  skip_deliverability_check: fieldSchema.yupBoolean().defined(),
+  scheduled_at_millis: fieldSchema.yupNumber().defined(),
+
+
+  // Source tracking for grouping emails by template/draft
+  created_with: fieldSchema.yupString().oneOf(["draft", "programmatic-call"]).defined(),
+  email_draft_id: fieldSchema.yupString().nullable().defined(),
+  email_programmatic_call_template_id: fieldSchema.yupString().nullable().defined(),
+
+  // Retry-related fields (for debugging/testing deferred retry logic)
+  send_retries: fieldSchema.yupNumber().defined(),
+  next_send_retry_at_millis: fieldSchema.yupNumber().nullable().defined(),
+  // Array of errors from each failed send attempt, each with internal/external messages
+  send_attempt_errors: fieldSchema.yupArray(fieldSchema.yupObject({
+    attempt_number: fieldSchema.yupNumber().defined(),
+    timestamp: fieldSchema.yupString().defined(),
+    external_message: fieldSchema.yupString().defined(),
+    external_details: fieldSchema.yupRecord(fieldSchema.yupString(), fieldSchema.jsonSchema).defined(),
+    internal_message: fieldSchema.yupString().defined(),
+    internal_details: fieldSchema.yupRecord(fieldSchema.yupString(), fieldSchema.jsonSchema).defined(),
+  }).defined()).nullable().defined(),
+
+  status: fieldSchema.yupString().defined(),
+  simple_status: fieldSchema.yupString().defined(),
+
+  // These fields are overridden because we use concat to build the final schema for each state
+  is_paused: fieldSchema.yupBoolean().oneOf([false]).defined(),
+  has_rendered: fieldSchema.yupBoolean().oneOf([false]).defined(),
+  has_delivered: fieldSchema.yupBoolean().oneOf([false]).defined(),
+}).defined();
+
+// Rendered output fields
+const renderedFieldsSchema = emailOutboxBaseSchema.concat(fieldSchema.yupObject({
+  started_rendering_at_millis: fieldSchema.yupNumber().defined(),
+  rendered_at_millis: fieldSchema.yupNumber().defined(),
+  subject: fieldSchema.yupString().defined(),
+  html: fieldSchema.yupString().nullable().defined(),
+  text: fieldSchema.yupString().nullable().defined(),
+  is_transactional: fieldSchema.yupBoolean().defined(),
+  is_high_priority: fieldSchema.yupBoolean().defined(),
+  notification_category_id: fieldSchema.yupString().nullable().defined(),
+  has_rendered: fieldSchema.yupBoolean().oneOf([true]).defined(),
+}).defined());
+
+const startedSendingFieldsSchema = renderedFieldsSchema.concat(fieldSchema.yupObject({
+  started_sending_at_millis: fieldSchema.yupNumber().defined(),
+}).defined());
+
+// Finished delivering tracking fields
+const finishedDeliveringFieldsSchema = startedSendingFieldsSchema.concat(fieldSchema.yupObject({
+  delivered_at_millis: fieldSchema.yupNumber().defined(),
+  has_delivered: fieldSchema.yupBoolean().oneOf([true]).defined(),
+}).defined());
+
+
+// =============================== STATUS-SPECIFIC SCHEMAS ===============================
+
+const pausedStatusSchema = emailOutboxBaseSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["paused"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["in-progress"]).defined(),
+  is_paused: fieldSchema.yupBoolean().oneOf([true]).defined(),
+}).defined());
+
+const preparingStatusSchema = emailOutboxBaseSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["preparing"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["in-progress"]).defined(),
+}).defined());
+
+const renderingStatusSchema = emailOutboxBaseSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["rendering"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["in-progress"]).defined(),
+  started_rendering_at_millis: fieldSchema.yupNumber().defined(),
+}).defined());
+
+const renderErrorStatusSchema = emailOutboxBaseSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["render-error"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["error"]).defined(),
+  started_rendering_at_millis: fieldSchema.yupNumber().defined(),
+  rendered_at_millis: fieldSchema.yupNumber().defined(),
+  render_error: fieldSchema.yupString().defined(),
+}).defined());
+
+const scheduledStatusSchema = renderedFieldsSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["scheduled"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["in-progress"]).defined(),
+  has_rendered: fieldSchema.yupBoolean().oneOf([true]).defined(),
+}).defined());
+
+const queuedStatusSchema = renderedFieldsSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["queued"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["in-progress"]).defined(),
+  has_rendered: fieldSchema.yupBoolean().oneOf([true]).defined(),
+}).defined());
+
+const sendingStatusSchema = startedSendingFieldsSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["sending"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["in-progress"]).defined(),
+}).defined());
+
+const serverErrorStatusSchema = startedSendingFieldsSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["server-error"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["error"]).defined(),
+  error_at_millis: fieldSchema.yupNumber().defined(),
+  server_error: fieldSchema.yupString().defined(),
+}).defined());
+
+// SKIPPED can happen at any time in the lifecycle (like PAUSED)
+// An email can be skipped before rendering (has_rendered: false) or after rendering (has_rendered: true)
+// e.g., user deleted after the email was rendered but before it was sent
+const skippedStatusSchema = emailOutboxBaseSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["skipped"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["ok"]).defined(),
+  skipped_at_millis: fieldSchema.yupNumber().defined(),
+  skipped_reason: fieldSchema.yupString().defined(),
+  skipped_details: fieldSchema.yupRecord(fieldSchema.yupString(), fieldSchema.jsonSchema).defined(),
+  // Override has_rendered to allow both true and false since email can be skipped at any time
+  has_rendered: fieldSchema.yupBoolean().defined(),
+  // These fields may or may not be present depending on when the email was skipped
+  started_rendering_at_millis: fieldSchema.yupNumber().optional(),
+  rendered_at_millis: fieldSchema.yupNumber().optional(),
+  subject: fieldSchema.yupString().optional(),
+  html: fieldSchema.yupString().nullable().optional(),
+  text: fieldSchema.yupString().nullable().optional(),
+  is_transactional: fieldSchema.yupBoolean().optional(),
+  is_high_priority: fieldSchema.yupBoolean().optional(),
+  notification_category_id: fieldSchema.yupString().nullable().optional(),
+  started_sending_at_millis: fieldSchema.yupNumber().optional(),
+}).defined());
+
+const bouncedStatusSchema = startedSendingFieldsSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["bounced"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["error"]).defined(),
+  bounced_at_millis: fieldSchema.yupNumber().defined(),
+}).defined());
+
+const deliveryDelayedStatusSchema = startedSendingFieldsSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["delivery-delayed"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["ok"]).defined(),
+  delivery_delayed_at_millis: fieldSchema.yupNumber().defined(),
+}).defined());
+
+const sentStatusSchema = finishedDeliveringFieldsSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["sent"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["ok"]).defined(),
+  // Whether this email's provider supports delivery tracking (opens, clicks, etc.)
+  can_have_delivery_info: fieldSchema.yupBoolean().defined(),
+}).defined());
+
+const openedStatusSchema = finishedDeliveringFieldsSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["opened"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["ok"]).defined(),
+  opened_at_millis: fieldSchema.yupNumber().defined(),
+  can_have_delivery_info: fieldSchema.yupBoolean().oneOf([true]).defined(),
+}).defined());
+
+const clickedStatusSchema = finishedDeliveringFieldsSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["clicked"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["ok"]).defined(),
+  clicked_at_millis: fieldSchema.yupNumber().defined(),
+  can_have_delivery_info: fieldSchema.yupBoolean().oneOf([true]).defined(),
+}).defined());
+
+const markedAsSpamStatusSchema = finishedDeliveringFieldsSchema.concat(fieldSchema.yupObject({
+  status: fieldSchema.yupString().oneOf(["marked-as-spam"]).defined(),
+  simple_status: fieldSchema.yupString().oneOf(["ok"]).defined(),
+  marked_as_spam_at_millis: fieldSchema.yupNumber().defined(),
+  can_have_delivery_info: fieldSchema.yupBoolean().oneOf([true]).defined(),
+}).defined());
+
+// Combined read schema using union
+export const emailOutboxReadSchema = fieldSchema.yupUnion(
+  pausedStatusSchema,
+  preparingStatusSchema,
+  renderingStatusSchema,
+  renderErrorStatusSchema,
+  scheduledStatusSchema,
+  queuedStatusSchema,
+  sendingStatusSchema,
+  serverErrorStatusSchema,
+  skippedStatusSchema,
+  bouncedStatusSchema,
+  deliveryDelayedStatusSchema,
+  sentStatusSchema,
+  openedStatusSchema,
+  clickedStatusSchema,
+  markedAsSpamStatusSchema
+);
+
+// Update schema for PATCH endpoint
+export const emailOutboxUpdateSchema = fieldSchema.yupObject({
+  tsx_source: fieldSchema.yupString().optional(),
+  theme_id: fieldSchema.yupString().nullable().optional(),
+  to: recipientSchema.optional(),
+  variables: fieldSchema.yupRecord(fieldSchema.yupString(), fieldSchema.jsonSchema).optional(),
+  skip_deliverability_check: fieldSchema.yupBoolean().optional(),
+  scheduled_at_millis: fieldSchema.yupNumber().optional(),
+  is_paused: fieldSchema.yupBoolean().optional(),
+  cancel: fieldSchema.yupBoolean().oneOf([true]).optional(),
+}).defined();
+
+export const emailOutboxCrud = createCrud({
+  serverReadSchema: emailOutboxReadSchema,
+  serverUpdateSchema: emailOutboxUpdateSchema,
+  docs: {
+    serverRead: {
+      tags: ["Emails"],
+      summary: "Get email outbox entry",
+      description: "Gets a single email from the outbox by ID.",
+    },
+    serverUpdate: {
+      tags: ["Emails"],
+      summary: "Update email outbox entry",
+      description: "Updates an email in the outbox. Can be used to edit email content, pause/resume, or cancel emails. Only emails in editable states (`paused`, `preparing`, `rendering`, `render-error`, `scheduled`, `queued`, `server-error`) can be modified.",
+    },
+    serverList: {
+      tags: ["Emails"],
+      summary: "List email outbox",
+      description: "Lists all emails in the outbox with optional filtering by status or simple_status.",
+    },
+  },
+});
+
+export type EmailOutboxCrud = CrudTypeOf<typeof emailOutboxCrud>;
+

package/src/interface/crud/email-templates.ts

@@ -0,0 +1,50 @@
+import { CrudTypeOf, createCrud } from "../../crud";
+import { jsonSchema, yupBoolean, yupMixed, yupObject, yupString } from "../../schema-fields";
+
+export type EmailTemplateType = typeof emailTemplateTypes[number];
+export const emailTemplateTypes = ['email_verification', 'password_reset', 'magic_link', 'team_invitation', 'sign_in_invitation', 'payment_receipt', 'payment_failed'] as const;
+
+export const emailTemplateAdminReadSchema = yupObject({
+  type: yupString().oneOf(emailTemplateTypes).defined(),
+  subject: yupString().defined(),
+  content: jsonSchema.defined(),
+  is_default: yupBoolean().defined(),
+}).defined();
+
+export const emailTemplateCrudAdminUpdateSchema = yupObject({
+  content: jsonSchema.nonNullable().optional(),
+  subject: yupString().optional(),
+}).defined();
+
+export const emailTemplateCrudAdminDeleteSchema = yupMixed();
+
+export const emailTemplateCrudAdminCreateSchema = yupObject({
+  type: yupString().oneOf(emailTemplateTypes).defined(),
+  content: jsonSchema.defined(),
+  subject: yupString().defined(),
+}).defined();
+
+export const emailTemplateCrud = createCrud({
+  adminReadSchema: emailTemplateAdminReadSchema,
+  adminUpdateSchema: emailTemplateCrudAdminUpdateSchema,
+  adminCreateSchema: emailTemplateCrudAdminCreateSchema,
+  adminDeleteSchema: emailTemplateCrudAdminDeleteSchema,
+  docs: {
+    adminRead: {
+      hidden: true,
+    },
+    adminCreate: {
+      hidden: true,
+    },
+    adminUpdate: {
+      hidden: true,
+    },
+    adminDelete: {
+      hidden: true,
+    },
+    adminList: {
+      hidden: true,
+    }
+  }
+});
+export type EmailTemplateCrud = CrudTypeOf<typeof emailTemplateCrud>;

package/src/interface/crud/emails.ts

@@ -0,0 +1,22 @@
+import { createCrud, CrudTypeOf } from "../../crud";
+import * as fieldSchema from "../../schema-fields";
+
+
+export const sentEmailReadSchema = fieldSchema.yupObject({
+  id: fieldSchema.yupString().defined(),
+  subject: fieldSchema.yupString().defined(),
+  sent_at_millis: fieldSchema.yupNumber().defined(),
+  to: fieldSchema.yupArray(fieldSchema.yupString().defined()),
+  error: fieldSchema.yupMixed().nullable().optional(),
+}).defined();
+
+export const internalEmailsCrud = createCrud({
+  adminReadSchema: sentEmailReadSchema,
+  docs: {
+    adminList: {
+      hidden: true,
+    },
+  },
+});
+
+export type InternalEmailsCrud = CrudTypeOf<typeof internalEmailsCrud>;