@stack0/sdk 0.5.1 → 0.5.3

package/dist/mail/index.d.mts

@@ -1,9 +1,11 @@
-import { a as HttpClientConfig } from '../http-client-Cgie_Rv6.mjs';
+import { H as HttpClient, a as HttpClientConfig } from '../http-client-Cgie_Rv6.mjs';
+import { E as Environment, P as PaginatedRequest, a as PaginatedResponse } from '../shared-types-CjKSP5Xc.mjs';
 
 /**
- * Type definitions for Stack0 Mail API
- * Compatible with Resend API for easy migration
+ * Stack0 Mail SDK Types
+ * Complete type definitions for the Mail API
  */
+
 interface EmailAddress {
     email: string;
     name?: string;
@@ -15,7 +17,10 @@ interface Attachment {
     contentType?: string;
     path?: string;
 }
+type EmailStatus = "pending" | "sent" | "delivered" | "bounced" | "failed" | "deferred" | "opened" | "clicked" | "complained" | "unsubscribed";
 interface SendEmailRequest {
+    projectSlug?: string;
+    environment?: Environment;
     from: EmailRecipient;
     to: EmailRecipient | EmailRecipient[];
     cc?: EmailRecipient | EmailRecipient[];
@@ -30,7 +35,7 @@ interface SendEmailRequest {
     metadata?: Record<string, unknown>;
     attachments?: Attachment[];
     headers?: Record<string, string>;
-    scheduledAt?: Date;
+    scheduledAt?: Date | string;
 }
 interface SendEmailResponse {
     id: string;
@@ -38,42 +43,1214 @@ interface SendEmailResponse {
     to: string;
     subject: string;
     status: string;
-    createdAt: Date;
+    createdAt: Date | string;
+}
+interface SendBatchEmailRequest {
+    projectSlug?: string;
+    emails: SendEmailRequest[];
+}
+interface SendBatchEmailResponse {
+    success: boolean;
+    data: Array<{
+        id: string;
+        success: boolean;
+        error?: string;
+    }>;
+}
+interface SendBroadcastEmailRequest {
+    projectSlug?: string;
+    environment?: Environment;
+    from: EmailRecipient;
+    to: EmailRecipient[];
+    subject: string;
+    html?: string;
+    text?: string;
+    templateId?: string;
+    templateVariables?: Record<string, unknown>;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    scheduledAt?: Date | string;
+}
+interface SendBroadcastEmailResponse {
+    success: boolean;
+    data: Array<{
+        id: string;
+        success: boolean;
+        error?: string;
+    }>;
+    count: number;
+    totalRequested?: number;
+    limitedByQuota?: boolean;
 }
 interface GetEmailResponse {
     id: string;
     from: string;
     to: string;
     subject: string;
-    status: "pending" | "sent" | "delivered" | "bounced" | "failed" | "deferred";
+    status: string;
     html: string | null;
     text: string | null;
     tags: string[] | null;
     metadata: Record<string, unknown> | null;
-    createdAt: Date;
-    sentAt: Date | null;
-    deliveredAt: Date | null;
-    openedAt: Date | null;
-    clickedAt: Date | null;
-    bouncedAt: Date | null;
+    createdAt: Date | string;
+    sentAt?: Date | string | null;
+    deliveredAt: Date | string | null;
+    openedAt: Date | string | null;
+    clickedAt: Date | string | null;
+    bouncedAt: Date | string | null;
     providerMessageId: string | null;
 }
-interface Stack0Error extends Error {
-    statusCode?: number;
-    code?: string;
-    response?: any;
+interface ListEmailsRequest extends PaginatedRequest {
+    projectSlug?: string;
+    environment?: Environment;
+    status?: EmailStatus;
+    from?: string;
+    to?: string;
+    subject?: string;
+    tag?: string;
+    startDate?: Date | string;
+    endDate?: Date | string;
+    sortBy?: "createdAt" | "deliveredAt" | "openedAt";
+    sortOrder?: "asc" | "desc";
+}
+interface Email {
+    id: string;
+    from: string;
+    to: string;
+    subject: string;
+    status: string;
+    cc: string | null;
+    replyTo: string | null;
+    messageId: string | null;
+    tags: string[] | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date | string;
+    deliveredAt: Date | string | null;
+    openedAt: Date | string | null;
+    clickedAt: Date | string | null;
+    bouncedAt: Date | string | null;
+    providerMessageId: string | null;
+}
+interface ListEmailsResponse extends PaginatedResponse {
+    emails: Email[];
+}
+interface ResendEmailResponse {
+    success: boolean;
+    data: {
+        id: string;
+        success: boolean;
+        error?: string;
+    };
+}
+interface CancelEmailResponse {
+    success: boolean;
+}
+interface EmailAnalyticsResponse {
+    total: number;
+    sent: number;
+    delivered: number;
+    bounced: number;
+    failed: number;
+    deliveryRate: number;
+    openRate: number;
+    clickRate: number;
+}
+interface TimeSeriesAnalyticsRequest {
+    days?: number;
+}
+interface TimeSeriesDataPoint {
+    date: string;
+    sent: number;
+    delivered: number;
+    opened: number;
+    clicked: number;
+    bounced: number;
+    failed: number;
+}
+interface TimeSeriesAnalyticsResponse {
+    data: TimeSeriesDataPoint[];
+}
+interface HourlyAnalyticsDataPoint {
+    hour: number;
+    sent: number;
+    delivered: number;
+    opened: number;
+    clicked: number;
+}
+interface HourlyAnalyticsResponse {
+    data: HourlyAnalyticsDataPoint[];
+}
+interface ListSendersRequest {
+    projectSlug?: string;
+    environment?: Environment;
+    search?: string;
+}
+interface Sender {
+    from: string;
+    total: number;
+    sent: number;
+    delivered: number;
+    bounced: number;
+    failed: number;
+}
+interface ListSendersResponse {
+    senders: Sender[];
+}
+type DomainStatus = "pending" | "verified" | "failed";
+interface DnsRecord {
+    type: string;
+    name: string;
+    value: string;
+    priority?: number;
+}
+interface Domain {
+    id: string;
+    organizationId: string;
+    domain: string;
+    status: DomainStatus;
+    dkimRecord: DnsRecord[] | null;
+    spfRecord: DnsRecord | null;
+    dmarcRecord: DnsRecord | null;
+    verificationToken: string | null;
+    sesVerificationRecord: DnsRecord | null;
+    isDefault: boolean;
+    verifiedAt: Date | string | null;
+    lastCheckedAt: Date | string | null;
+    createdAt: Date | string;
+    updatedAt: Date | string | null;
+}
+interface ListDomainsRequest {
+    projectSlug: string;
+    environment?: Environment;
+}
+type ListDomainsResponse = Domain[];
+interface AddDomainRequest {
+    domain: string;
+}
+interface AddDomainResponse {
+    domain?: Domain;
+    dnsRecords: {
+        domain: string;
+        dkimRecords: DnsRecord[];
+        spfRecord: DnsRecord;
+        dmarcRecord: DnsRecord;
+        verificationToken: string;
+        sesVerificationRecord?: DnsRecord;
+    };
+}
+interface GetDnsRecordsResponse {
+    domain: string;
+    dkimRecords: DnsRecord[] | null;
+    spfRecord: DnsRecord | null;
+    dmarcRecord: DnsRecord | null;
+    sesVerificationRecord: DnsRecord | null;
+    status: DomainStatus;
+    verifiedAt: Date | string | null;
+    verificationDetails?: {
+        domainVerified: boolean;
+        dkimVerified: boolean;
+        verificationStatus: string;
+        dkimStatus: string;
+    };
+}
+interface VerifyDomainResponse {
+    verified: boolean;
+    message: string;
+}
+interface DeleteDomainResponse {
+    success: boolean;
+}
+type SetDefaultDomainResponse = Domain;
+interface Template {
+    id: string;
+    organizationId: string;
+    environment: Environment;
+    createdByUserId: string | null;
+    name: string;
+    slug: string;
+    description: string | null;
+    subject: string;
+    previewText: string | null;
+    html: string;
+    text: string | null;
+    mailyJson: Record<string, unknown> | null;
+    variablesSchema: Record<string, unknown> | null;
+    isActive: boolean;
+    createdAt: Date | string;
+    updatedAt: Date | string | null;
+}
+interface CreateTemplateRequest {
+    environment?: Environment;
+    name: string;
+    slug: string;
+    description?: string;
+    subject: string;
+    previewText?: string;
+    html: string;
+    text?: string;
+    mailyJson?: Record<string, unknown>;
+    variablesSchema?: Record<string, unknown>;
+    isActive?: boolean;
+}
+interface UpdateTemplateRequest {
+    id: string;
+    name?: string;
+    slug?: string;
+    description?: string;
+    subject?: string;
+    previewText?: string;
+    html?: string;
+    text?: string;
+    mailyJson?: Record<string, unknown>;
+    variablesSchema?: Record<string, unknown>;
+    isActive?: boolean;
+}
+interface ListTemplatesRequest extends PaginatedRequest {
+    environment?: Environment;
+    isActive?: boolean;
+    search?: string;
+}
+interface ListTemplatesResponse extends PaginatedResponse {
+    templates: Template[];
+}
+interface DeleteTemplateResponse {
+    success: boolean;
+}
+interface PreviewTemplateRequest {
+    id: string;
+    variables: Record<string, unknown>;
+}
+interface PreviewTemplateResponse {
+    subject: string;
+    html: string;
+    text: string | null;
+}
+interface Audience {
+    id: string;
+    organizationId: string;
+    projectId: string | null;
+    environment: string;
+    name: string;
+    description: string | null;
+    totalContacts: number;
+    subscribedContacts: number;
+    unsubscribedContacts: number;
+    createdByUserId: string | null;
+    createdAt: Date | string;
+    updatedAt: Date | string | null;
+}
+interface CreateAudienceRequest {
+    environment?: Environment;
+    name: string;
+    description?: string;
+}
+interface UpdateAudienceRequest {
+    id: string;
+    name?: string;
+    description?: string;
+}
+interface ListAudiencesRequest extends PaginatedRequest {
+    environment?: Environment;
+    search?: string;
+}
+interface ListAudiencesResponse extends PaginatedResponse {
+    audiences: Audience[];
+}
+interface DeleteAudienceResponse {
+    success: boolean;
+}
+interface AddContactsToAudienceRequest {
+    id: string;
+    contactIds: string[];
+}
+interface AddContactsToAudienceResponse {
+    success: boolean;
+    added: number;
+}
+interface RemoveContactsFromAudienceRequest {
+    id: string;
+    contactIds: string[];
+}
+interface RemoveContactsFromAudienceResponse {
+    success: boolean;
+    removed: number;
+}
+type ContactStatus = "subscribed" | "unsubscribed" | "bounced" | "complained";
+interface MailContact {
+    id: string;
+    organizationId: string;
+    projectId: string | null;
+    environment: string;
+    email: string;
+    firstName: string | null;
+    lastName: string | null;
+    metadata: Record<string, unknown> | null;
+    status: string;
+    subscribedAt: Date | string | null;
+    unsubscribedAt: Date | string | null;
+    createdAt: Date | string;
+    updatedAt: Date | string | null;
+}
+interface AudienceContact extends MailContact {
+    addedAt: Date | string | null;
+}
+interface CreateContactRequest {
+    environment?: Environment;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateContactRequest {
+    id: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    metadata?: Record<string, unknown>;
+    status?: ContactStatus;
+}
+interface ListContactsRequest extends PaginatedRequest {
+    environment?: Environment;
+    search?: string;
+    status?: ContactStatus;
+}
+interface ListContactsResponse extends PaginatedResponse {
+    contacts: MailContact[];
+}
+interface ListAudienceContactsRequest extends PaginatedRequest {
+    id: string;
+    environment?: Environment;
+    search?: string;
+    status?: ContactStatus;
+}
+interface ListAudienceContactsResponse extends PaginatedResponse {
+    contacts: AudienceContact[];
+}
+interface DeleteContactResponse {
+    success: boolean;
+}
+interface ImportContactsRequest {
+    environment?: Environment;
+    audienceId?: string;
+    contacts: Array<{
+        email: string;
+        firstName?: string;
+        lastName?: string;
+        metadata?: Record<string, unknown>;
+    }>;
+}
+interface ImportContactsResponse {
+    success: boolean;
+    imported: number;
+    skipped: number;
+    errors: Array<{
+        email: string;
+        error: string;
+    }>;
+}
+type CampaignStatus = "draft" | "scheduled" | "sending" | "sent" | "paused" | "cancelled" | "failed";
+interface Campaign {
+    id: string;
+    organizationId: string;
+    projectId: string | null;
+    environment: string;
+    name: string;
+    subject: string;
+    previewText: string | null;
+    fromEmail: string;
+    fromName: string | null;
+    replyTo: string | null;
+    templateId: string | null;
+    html: string | null;
+    text: string | null;
+    audienceId: string | null;
+    status: string;
+    scheduledAt: Date | string | null;
+    sentAt: Date | string | null;
+    completedAt: Date | string | null;
+    totalRecipients: number;
+    sentCount: number;
+    deliveredCount: number;
+    openedCount: number;
+    clickedCount: number;
+    bouncedCount: number;
+    failedCount: number;
+    tags: string[] | null;
+    metadata: Record<string, unknown> | null;
+    createdByUserId: string | null;
+    createdAt: Date | string;
+    updatedAt: Date | string | null;
+}
+interface CreateCampaignRequest {
+    environment?: Environment;
+    name: string;
+    subject: string;
+    previewText?: string;
+    fromEmail: string;
+    fromName?: string;
+    replyTo?: string;
+    templateId?: string;
+    html?: string;
+    text?: string;
+    audienceId?: string;
+    scheduledAt?: Date | string;
+    tags?: string[];
+}
+interface UpdateCampaignRequest {
+    id: string;
+    name?: string;
+    subject?: string;
+    previewText?: string;
+    fromEmail?: string;
+    fromName?: string;
+    replyTo?: string;
+    templateId?: string;
+    html?: string;
+    text?: string;
+    audienceId?: string;
+    scheduledAt?: Date | string;
+    tags?: string[];
+}
+interface ListCampaignsRequest extends PaginatedRequest {
+    environment?: Environment;
+    search?: string;
+    status?: CampaignStatus;
+}
+interface ListCampaignsResponse extends PaginatedResponse {
+    campaigns: Campaign[];
+}
+interface DeleteCampaignResponse {
+    success: boolean;
+}
+interface SendCampaignRequest {
+    id: string;
+    sendNow?: boolean;
+    scheduledAt?: Date | string;
+}
+interface SendCampaignResponse {
+    success: boolean;
+    sentCount: number;
+    failedCount: number;
+    totalRecipients: number;
+}
+interface PauseCampaignResponse {
+    success: boolean;
+}
+interface CancelCampaignResponse {
+    success: boolean;
+}
+interface CampaignStatsResponse {
+    total: number;
+    sent: number;
+    delivered: number;
+    opened: number;
+    clicked: number;
+    bounced: number;
+    failed: number;
+    deliveryRate: number;
+    openRate: number;
+    clickRate: number;
+    bounceRate: number;
+}
+type SequenceStatus = "draft" | "active" | "paused" | "archived";
+type SequenceTriggerType = "manual" | "event_received" | "contact_added" | "api" | "scheduled";
+type SequenceTriggerFrequency = "once" | "always";
+type SequenceNodeType = "trigger" | "email" | "timer" | "filter" | "branch" | "experiment" | "exit" | "add_to_list" | "update_contact";
+type ConnectionType = "default" | "yes" | "no" | "branch" | "variant";
+interface Sequence {
+    id: string;
+    organizationId: string;
+    environment: string;
+    name: string;
+    description: string | null;
+    triggerType: SequenceTriggerType;
+    triggerFrequency: SequenceTriggerFrequency;
+    triggerConfig: Record<string, unknown> | null;
+    audienceFilterId: string | null;
+    status: SequenceStatus;
+    totalEntered: number;
+    totalCompleted: number;
+    totalActive: number;
+    publishedAt: Date | string | null;
+    pausedAt: Date | string | null;
+    archivedAt: Date | string | null;
+    createdByUserId: string | null;
+    createdAt: Date | string;
+    updatedAt: Date | string | null;
+}
+interface SequenceNode {
+    id: string;
+    loopId: string;
+    nodeType: SequenceNodeType;
+    name: string;
+    positionX: number;
+    positionY: number;
+    sortOrder: number;
+    config: Record<string, unknown> | null;
+    createdAt: Date | string;
+    updatedAt: Date | string | null;
+}
+interface SequenceConnection {
+    id: string;
+    loopId: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    connectionType: ConnectionType;
+    label: string | null;
+    createdAt: Date | string;
+}
+interface SequenceWithNodes extends Sequence {
+    nodes: SequenceNode[];
+    connections: SequenceConnection[];
+}
+interface CreateSequenceRequest {
+    environment?: Environment;
+    name: string;
+    description?: string;
+    triggerType: SequenceTriggerType;
+    triggerFrequency?: SequenceTriggerFrequency;
+    triggerConfig?: Record<string, unknown>;
+    audienceFilterId?: string;
+}
+interface UpdateSequenceRequest {
+    id: string;
+    name?: string;
+    description?: string;
+    triggerType?: SequenceTriggerType;
+    triggerFrequency?: SequenceTriggerFrequency;
+    triggerConfig?: Record<string, unknown>;
+    audienceFilterId?: string;
+}
+interface ListSequencesRequest extends PaginatedRequest {
+    environment?: Environment;
+    search?: string;
+    status?: SequenceStatus;
+    triggerType?: SequenceTriggerType;
+}
+interface ListSequencesResponse extends PaginatedResponse {
+    sequences: Sequence[];
+}
+interface DeleteSequenceResponse {
+    success: boolean;
+}
+interface PublishSequenceResponse {
+    success: boolean;
+}
+interface PauseSequenceResponse {
+    success: boolean;
+}
+interface ResumeSequenceResponse {
+    success: boolean;
+}
+interface ArchiveSequenceResponse {
+    success: boolean;
+}
+interface CreateNodeRequest {
+    id: string;
+    nodeType: SequenceNodeType;
+    name: string;
+    positionX: number;
+    positionY: number;
+    sortOrder?: number;
+    config?: Record<string, unknown>;
+}
+interface UpdateNodeRequest {
+    id: string;
+    nodeId: string;
+    name?: string;
+    positionX?: number;
+    positionY?: number;
+    sortOrder?: number;
+    config?: Record<string, unknown>;
+}
+interface UpdateNodePositionRequest {
+    id: string;
+    nodeId: string;
+    positionX: number;
+    positionY: number;
+}
+interface DeleteNodeResponse {
+    success: boolean;
+}
+interface SetNodeEmailRequest {
+    nodeId: string;
+    subject?: string;
+    previewText?: string;
+    html?: string;
+    text?: string;
+    templateId?: string;
+    mailyJson?: Record<string, unknown>;
+    fromEmail?: string;
+    fromName?: string;
+    replyTo?: string;
+}
+interface SetNodeTimerRequest {
+    nodeId: string;
+    delayAmount: number;
+    delayUnit: "minutes" | "hours" | "days" | "weeks";
+    waitUntilTime?: string;
+    waitUntilTimezone?: string;
+}
+interface SetNodeFilterRequest {
+    nodeId: string;
+    conditions: Record<string, unknown>;
+    nonMatchAction?: "stop" | "continue";
+}
+interface SetNodeBranchRequest {
+    nodeId: string;
+    branches: Array<{
+        name: string;
+        conditions: Record<string, unknown>;
+    }>;
+    hasDefaultBranch?: boolean;
+}
+interface SetNodeExperimentRequest {
+    nodeId: string;
+    sampleSize?: number;
+    variants: Array<{
+        name: string;
+        weight: number;
+    }>;
+}
+interface CreateConnectionRequest {
+    id: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    connectionType?: ConnectionType;
+    label?: string;
+}
+interface DeleteConnectionResponse {
+    success: boolean;
+}
+type SequenceEntryStatus = "active" | "paused" | "completed" | "stopped" | "failed";
+interface SequenceEntry {
+    id: string;
+    loopId: string;
+    contactId: string;
+    currentNodeId: string | null;
+    status: SequenceEntryStatus;
+    enteredAt: Date | string;
+    exitedAt: Date | string | null;
+    exitReason: string | null;
+    contact?: MailContact;
+}
+interface ListSequenceEntriesRequest extends PaginatedRequest {
+    id: string;
+    status?: SequenceEntryStatus;
+}
+interface ListSequenceEntriesResponse extends PaginatedResponse {
+    entries: SequenceEntry[];
+}
+interface AddContactToSequenceRequest {
+    id: string;
+    contactId: string;
+}
+interface RemoveContactFromSequenceRequest {
+    id: string;
+    entryId: string;
+    reason?: string;
+}
+interface RemoveContactFromSequenceResponse {
+    success: boolean;
+}
+interface SequenceAnalyticsResponse {
+    sequence: {
+        totalEntered: number;
+        totalCompleted: number;
+        totalActive: number;
+    };
+    statusBreakdown: Record<string, number>;
+    nodeAnalytics: Array<{
+        nodeId: string;
+        entered: number;
+        exited: number;
+        emailsSent: number;
+        emailsDelivered: number;
+        emailsOpened: number;
+        emailsClicked: number;
+        emailsBounced: number;
+        passed: number;
+        filtered: number;
+    }>;
+}
+interface EventProperty {
+    name: string;
+    type: "string" | "number" | "boolean" | "date" | "object" | "array";
+    description?: string;
+    required?: boolean;
+}
+interface EventPropertiesSchema {
+    properties: EventProperty[];
+}
+interface MailEvent {
+    id: string;
+    organizationId: string;
+    projectId: string | null;
+    environment: string;
+    name: string;
+    description: string | null;
+    propertiesSchema: EventPropertiesSchema | null;
+    totalReceived: number;
+    lastReceivedAt: Date | string | null;
+    createdAt: Date | string;
+    updatedAt: Date | string | null;
+}
+interface CreateEventRequest {
+    projectSlug?: string;
+    environment?: Environment;
+    name: string;
+    description?: string;
+    propertiesSchema?: EventPropertiesSchema;
+}
+interface UpdateEventRequest {
+    id: string;
+    name?: string;
+    description?: string;
+    propertiesSchema?: EventPropertiesSchema;
+}
+interface ListEventsRequest extends PaginatedRequest {
+    projectSlug?: string;
+    environment?: Environment;
+    search?: string;
+}
+interface ListEventsResponse extends PaginatedResponse {
+    events: MailEvent[];
+}
+interface DeleteEventResponse {
+    success: boolean;
+}
+interface TrackEventRequest {
+    environment?: Environment;
+    eventName: string;
+    contactId?: string;
+    contactEmail?: string;
+    properties?: Record<string, unknown>;
+}
+interface TrackEventResponse {
+    success: boolean;
+    eventOccurrenceId?: string;
+    error?: string;
+}
+interface BatchTrackEventsRequest {
+    environment?: Environment;
+    events: Array<{
+        eventName: string;
+        contactId?: string;
+        contactEmail?: string;
+        properties?: Record<string, unknown>;
+        timestamp?: Date | string;
+    }>;
+}
+interface BatchTrackEventsResponse {
+    success: boolean;
+    results: Array<{
+        success: boolean;
+        eventOccurrenceId?: string;
+        error?: string;
+    }>;
+    totalProcessed: number;
+    totalFailed: number;
+}
+interface EventOccurrence {
+    id: string;
+    eventId: string;
+    contactId: string;
+    properties: Record<string, unknown> | null;
+    processed: boolean;
+    processedAt: Date | string | null;
+    createdAt: Date | string;
+}
+interface ListEventOccurrencesRequest extends PaginatedRequest {
+    eventId?: string;
+    contactId?: string;
+    startDate?: Date | string;
+    endDate?: Date | string;
+}
+interface ListEventOccurrencesResponse extends PaginatedResponse {
+    occurrences: EventOccurrence[];
+}
+interface EventAnalyticsResponse {
+    totalReceived: number;
+    lastReceivedAt: Date | string | null;
+    uniqueContacts: number;
+    dailyCounts: Array<{
+        date: string;
+        count: number;
+    }>;
+}
+
+/**
+ * Audiences client for Stack0 Mail API
+ */
+
+declare class Audiences {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all audiences
+     */
+    list(request?: ListAudiencesRequest): Promise<ListAudiencesResponse>;
+    /**
+     * Get an audience by ID
+     */
+    get(id: string): Promise<Audience>;
+    /**
+     * Create a new audience
+     */
+    create(request: CreateAudienceRequest): Promise<Audience>;
+    /**
+     * Update an audience
+     */
+    update(request: UpdateAudienceRequest): Promise<Audience>;
+    /**
+     * Delete an audience
+     */
+    delete(id: string): Promise<DeleteAudienceResponse>;
+    /**
+     * List contacts in an audience
+     */
+    listContacts(request: ListAudienceContactsRequest): Promise<ListAudienceContactsResponse>;
+    /**
+     * Add contacts to an audience
+     */
+    addContacts(request: AddContactsToAudienceRequest): Promise<AddContactsToAudienceResponse>;
+    /**
+     * Remove contacts from an audience
+     */
+    removeContacts(request: RemoveContactsFromAudienceRequest): Promise<RemoveContactsFromAudienceResponse>;
+}
+
+/**
+ * Campaigns client for Stack0 Mail API
+ */
+
+declare class Campaigns {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all campaigns
+     */
+    list(request?: ListCampaignsRequest): Promise<ListCampaignsResponse>;
+    /**
+     * Get a campaign by ID
+     */
+    get(id: string): Promise<Campaign>;
+    /**
+     * Create a new campaign
+     */
+    create(request: CreateCampaignRequest): Promise<Campaign>;
+    /**
+     * Update a campaign
+     */
+    update(request: UpdateCampaignRequest): Promise<Campaign>;
+    /**
+     * Delete a campaign
+     */
+    delete(id: string): Promise<DeleteCampaignResponse>;
+    /**
+     * Send a campaign
+     */
+    send(request: SendCampaignRequest): Promise<SendCampaignResponse>;
+    /**
+     * Pause a sending campaign
+     */
+    pause(id: string): Promise<PauseCampaignResponse>;
+    /**
+     * Cancel a campaign
+     */
+    cancel(id: string): Promise<CancelCampaignResponse>;
+    /**
+     * Duplicate a campaign
+     */
+    duplicate(id: string): Promise<Campaign>;
+    /**
+     * Get campaign statistics
+     */
+    getStats(id: string): Promise<CampaignStatsResponse>;
+}
+
+/**
+ * Contacts client for Stack0 Mail API
+ */
+
+declare class Contacts {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all contacts
+     */
+    list(request?: ListContactsRequest): Promise<ListContactsResponse>;
+    /**
+     * Get a contact by ID
+     */
+    get(id: string): Promise<MailContact>;
+    /**
+     * Create a new contact
+     */
+    create(request: CreateContactRequest): Promise<MailContact>;
+    /**
+     * Update a contact
+     */
+    update(request: UpdateContactRequest): Promise<MailContact>;
+    /**
+     * Delete a contact
+     */
+    delete(id: string): Promise<DeleteContactResponse>;
+    /**
+     * Import contacts in bulk
+     */
+    import(request: ImportContactsRequest): Promise<ImportContactsResponse>;
+}
+
+/**
+ * Domains client for Stack0 Mail API
+ */
+
+declare class Domains {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all domains for the organization
+     */
+    list(request: ListDomainsRequest): Promise<ListDomainsResponse>;
+    /**
+     * Add a new domain
+     */
+    add(request: AddDomainRequest): Promise<AddDomainResponse>;
+    /**
+     * Get DNS records for a domain
+     */
+    getDnsRecords(domainId: string): Promise<GetDnsRecordsResponse>;
+    /**
+     * Verify a domain
+     */
+    verify(domainId: string): Promise<VerifyDomainResponse>;
+    /**
+     * Delete a domain
+     */
+    delete(domainId: string): Promise<DeleteDomainResponse>;
+    /**
+     * Set a domain as the default
+     */
+    setDefault(domainId: string): Promise<SetDefaultDomainResponse>;
+}
+
+/**
+ * Events client for Stack0 Mail API
+ */
+
+declare class Events {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all event definitions
+     */
+    list(request?: ListEventsRequest): Promise<ListEventsResponse>;
+    /**
+     * Get an event definition by ID
+     */
+    get(id: string): Promise<MailEvent>;
+    /**
+     * Create a new event definition
+     */
+    create(request: CreateEventRequest): Promise<MailEvent>;
+    /**
+     * Update an event definition
+     */
+    update(request: UpdateEventRequest): Promise<MailEvent>;
+    /**
+     * Delete an event definition
+     */
+    delete(id: string): Promise<DeleteEventResponse>;
+    /**
+     * Track a single event
+     * This can trigger email sequences configured to listen for this event
+     */
+    track(request: TrackEventRequest): Promise<TrackEventResponse>;
+    /**
+     * Track multiple events in a batch (max 100)
+     */
+    trackBatch(request: BatchTrackEventsRequest): Promise<BatchTrackEventsResponse>;
+    /**
+     * List event occurrences
+     */
+    listOccurrences(request?: ListEventOccurrencesRequest): Promise<ListEventOccurrencesResponse>;
+    /**
+     * Get analytics for an event
+     */
+    getAnalytics(id: string): Promise<EventAnalyticsResponse>;
+}
+
+/**
+ * Sequences client for Stack0 Mail API
+ */
+
+declare class Sequences {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all sequences
+     */
+    list(request?: ListSequencesRequest): Promise<ListSequencesResponse>;
+    /**
+     * Get a sequence by ID with all nodes and connections
+     */
+    get(id: string): Promise<SequenceWithNodes>;
+    /**
+     * Create a new sequence
+     */
+    create(request: CreateSequenceRequest): Promise<Sequence>;
+    /**
+     * Update a sequence
+     */
+    update(request: UpdateSequenceRequest): Promise<Sequence>;
+    /**
+     * Delete a sequence
+     */
+    delete(id: string): Promise<DeleteSequenceResponse>;
+    /**
+     * Publish (activate) a sequence
+     */
+    publish(id: string): Promise<PublishSequenceResponse>;
+    /**
+     * Pause an active sequence
+     */
+    pause(id: string): Promise<PauseSequenceResponse>;
+    /**
+     * Resume a paused sequence
+     */
+    resume(id: string): Promise<ResumeSequenceResponse>;
+    /**
+     * Archive a sequence
+     */
+    archive(id: string): Promise<ArchiveSequenceResponse>;
+    /**
+     * Duplicate a sequence
+     */
+    duplicate(id: string, name?: string): Promise<Sequence>;
+    /**
+     * Create a new node in a sequence
+     */
+    createNode(request: CreateNodeRequest): Promise<SequenceNode>;
+    /**
+     * Update a node
+     */
+    updateNode(request: UpdateNodeRequest): Promise<SequenceNode>;
+    /**
+     * Update node position (for visual editor)
+     */
+    updateNodePosition(request: UpdateNodePositionRequest): Promise<SequenceNode>;
+    /**
+     * Delete a node
+     */
+    deleteNode(sequenceId: string, nodeId: string): Promise<DeleteNodeResponse>;
+    /**
+     * Set email node content
+     */
+    setNodeEmail(sequenceId: string, request: SetNodeEmailRequest): Promise<SequenceNode>;
+    /**
+     * Set timer node configuration
+     */
+    setNodeTimer(sequenceId: string, request: SetNodeTimerRequest): Promise<SequenceNode>;
+    /**
+     * Set filter node configuration
+     */
+    setNodeFilter(sequenceId: string, request: SetNodeFilterRequest): Promise<SequenceNode>;
+    /**
+     * Set branch node configuration
+     */
+    setNodeBranch(sequenceId: string, request: SetNodeBranchRequest): Promise<SequenceNode>;
+    /**
+     * Set experiment node configuration
+     */
+    setNodeExperiment(sequenceId: string, request: SetNodeExperimentRequest): Promise<SequenceNode>;
+    /**
+     * Create a connection between nodes
+     */
+    createConnection(request: CreateConnectionRequest): Promise<SequenceConnection>;
+    /**
+     * Delete a connection
+     */
+    deleteConnection(sequenceId: string, connectionId: string): Promise<DeleteConnectionResponse>;
+    /**
+     * List contacts in a sequence
+     */
+    listEntries(request: ListSequenceEntriesRequest): Promise<ListSequenceEntriesResponse>;
+    /**
+     * Add a contact to a sequence
+     */
+    addContact(request: AddContactToSequenceRequest): Promise<SequenceEntry>;
+    /**
+     * Remove a contact from a sequence
+     */
+    removeContact(request: RemoveContactFromSequenceRequest): Promise<RemoveContactFromSequenceResponse>;
+    /**
+     * Get sequence analytics
+     */
+    getAnalytics(id: string): Promise<SequenceAnalyticsResponse>;
+}
+
+/**
+ * Templates client for Stack0 Mail API
+ */
+
+declare class Templates {
+    private http;
+    constructor(http: HttpClient);
+    /**
+     * List all templates
+     */
+    list(request?: ListTemplatesRequest): Promise<ListTemplatesResponse>;
+    /**
+     * Get a template by ID
+     */
+    get(id: string): Promise<Template>;
+    /**
+     * Get a template by slug
+     */
+    getBySlug(slug: string): Promise<Template>;
+    /**
+     * Create a new template
+     */
+    create(request: CreateTemplateRequest): Promise<Template>;
+    /**
+     * Update a template
+     */
+    update(request: UpdateTemplateRequest): Promise<Template>;
+    /**
+     * Delete a template
+     */
+    delete(id: string): Promise<DeleteTemplateResponse>;
+    /**
+     * Preview a template with variables
+     */
+    preview(request: PreviewTemplateRequest): Promise<PreviewTemplateResponse>;
 }
 
 /**
  * Stack0 Mail Client
- * API compatible with Resend for easy migration
+ * Complete email API with support for transactional emails, campaigns, sequences, and more
  */
 
 declare class Mail {
     private http;
+    /** Manage sending domains */
+    readonly domains: Domains;
+    /** Manage email templates */
+    readonly templates: Templates;
+    /** Manage contact audiences/lists */
+    readonly audiences: Audiences;
+    /** Manage contacts */
+    readonly contacts: Contacts;
+    /** Manage email campaigns */
+    readonly campaigns: Campaigns;
+    /** Manage automated email sequences */
+    readonly sequences: Sequences;
+    /** Track and manage custom events */
+    readonly events: Events;
     constructor(config: HttpClientConfig);
     /**
-     * Send an email
+     * Send a single email
      *
      * @example
      * ```typescript
@@ -86,6 +1263,35 @@ declare class Mail {
      * ```
      */
     send(request: SendEmailRequest): Promise<SendEmailResponse>;
+    /**
+     * Send multiple emails in a batch (up to 100)
+     * Each email can have different content and recipients
+     *
+     * @example
+     * ```typescript
+     * const result = await mail.sendBatch({
+     *   emails: [
+     *     { from: 'noreply@example.com', to: 'user1@example.com', subject: 'Hello', html: '<p>Hi User 1</p>' },
+     *     { from: 'noreply@example.com', to: 'user2@example.com', subject: 'Hello', html: '<p>Hi User 2</p>' },
+     *   ]
+     * });
+     * ```
+     */
+    sendBatch(request: SendBatchEmailRequest): Promise<SendBatchEmailResponse>;
+    /**
+     * Send a broadcast email (same content to multiple recipients, up to 1000)
+     *
+     * @example
+     * ```typescript
+     * const result = await mail.sendBroadcast({
+     *   from: 'noreply@example.com',
+     *   to: ['user1@example.com', 'user2@example.com', 'user3@example.com'],
+     *   subject: 'Newsletter',
+     *   html: '<p>Our latest updates...</p>',
+     * });
+     * ```
+     */
+    sendBroadcast(request: SendBroadcastEmailRequest): Promise<SendBroadcastEmailResponse>;
     /**
      * Get email details by ID
      *
@@ -96,6 +1302,42 @@ declare class Mail {
      * ```
      */
     get(id: string): Promise<GetEmailResponse>;
+    /**
+     * List emails with optional filters
+     *
+     * @example
+     * ```typescript
+     * const result = await mail.list({
+     *   status: 'delivered',
+     *   limit: 50,
+     * });
+     * ```
+     */
+    list(request?: ListEmailsRequest): Promise<ListEmailsResponse>;
+    /**
+     * Resend a previously sent email
+     */
+    resend(id: string): Promise<ResendEmailResponse>;
+    /**
+     * Cancel a scheduled email
+     */
+    cancel(id: string): Promise<CancelEmailResponse>;
+    /**
+     * Get overall email analytics
+     */
+    getAnalytics(): Promise<EmailAnalyticsResponse>;
+    /**
+     * Get time series analytics (daily breakdown)
+     */
+    getTimeSeriesAnalytics(request?: TimeSeriesAnalyticsRequest): Promise<TimeSeriesAnalyticsResponse>;
+    /**
+     * Get hourly analytics
+     */
+    getHourlyAnalytics(): Promise<HourlyAnalyticsResponse>;
+    /**
+     * List unique senders with their statistics
+     */
+    listSenders(request?: ListSendersRequest): Promise<ListSendersResponse>;
 }
 
-export { type Attachment, type EmailAddress, type EmailRecipient, type GetEmailResponse, Mail, type SendEmailRequest, type SendEmailResponse, type Stack0Error };
+export { type AddContactToSequenceRequest, type AddContactsToAudienceRequest, type AddContactsToAudienceResponse, type AddDomainRequest, type AddDomainResponse, type ArchiveSequenceResponse, type Attachment, type Audience, type AudienceContact, Audiences, type BatchTrackEventsRequest, type BatchTrackEventsResponse, type Campaign, type CampaignStatsResponse, type CampaignStatus, Campaigns, type CancelCampaignResponse, type CancelEmailResponse, type ConnectionType, type ContactStatus, Contacts, type CreateAudienceRequest, type CreateCampaignRequest, type CreateConnectionRequest, type CreateContactRequest, type CreateEventRequest, type CreateNodeRequest, type CreateSequenceRequest, type CreateTemplateRequest, type DeleteAudienceResponse, type DeleteCampaignResponse, type DeleteConnectionResponse, type DeleteContactResponse, type DeleteDomainResponse, type DeleteEventResponse, type DeleteNodeResponse, type DeleteSequenceResponse, type DeleteTemplateResponse, type DnsRecord, type Domain, type DomainStatus, Domains, type Email, type EmailAddress, type EmailAnalyticsResponse, type EmailRecipient, type EmailStatus, type EventAnalyticsResponse, type EventOccurrence, type EventPropertiesSchema, type EventProperty, Events, type GetDnsRecordsResponse, type GetEmailResponse, type HourlyAnalyticsDataPoint, type HourlyAnalyticsResponse, type ImportContactsRequest, type ImportContactsResponse, type ListAudienceContactsRequest, type ListAudienceContactsResponse, type ListAudiencesRequest, type ListAudiencesResponse, type ListCampaignsRequest, type ListCampaignsResponse, type ListContactsRequest, type ListContactsResponse, type ListDomainsRequest, type ListDomainsResponse, type ListEmailsRequest, type ListEmailsResponse, type ListEventOccurrencesRequest, type ListEventOccurrencesResponse, type ListEventsRequest, type ListEventsResponse, type ListSendersRequest, type ListSendersResponse, type ListSequenceEntriesRequest, type ListSequenceEntriesResponse, type ListSequencesRequest, type ListSequencesResponse, type ListTemplatesRequest, type ListTemplatesResponse, Mail, type MailContact, type MailEvent, type PauseCampaignResponse, type PauseSequenceResponse, type PreviewTemplateRequest, type PreviewTemplateResponse, type PublishSequenceResponse, type RemoveContactFromSequenceRequest, type RemoveContactFromSequenceResponse, type RemoveContactsFromAudienceRequest, type RemoveContactsFromAudienceResponse, type ResendEmailResponse, type ResumeSequenceResponse, type SendBatchEmailRequest, type SendBatchEmailResponse, type SendBroadcastEmailRequest, type SendBroadcastEmailResponse, type SendCampaignRequest, type SendCampaignResponse, type SendEmailRequest, type SendEmailResponse, type Sender, type Sequence, type SequenceAnalyticsResponse, type SequenceConnection, type SequenceEntry, type SequenceEntryStatus, type SequenceNode, type SequenceNodeType, type SequenceStatus, type SequenceTriggerFrequency, type SequenceTriggerType, type SequenceWithNodes, Sequences, type SetDefaultDomainResponse, type SetNodeBranchRequest, type SetNodeEmailRequest, type SetNodeExperimentRequest, type SetNodeFilterRequest, type SetNodeTimerRequest, type Template, Templates, type TimeSeriesAnalyticsRequest, type TimeSeriesAnalyticsResponse, type TimeSeriesDataPoint, type TrackEventRequest, type TrackEventResponse, type UpdateAudienceRequest, type UpdateCampaignRequest, type UpdateContactRequest, type UpdateEventRequest, type UpdateNodePositionRequest, type UpdateNodeRequest, type UpdateSequenceRequest, type UpdateTemplateRequest, type VerifyDomainResponse };