migma 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,1066 @@
+declare enum MigmaErrorCode {
+    VALIDATION_ERROR = "validation_error",
+    NOT_FOUND = "not_found",
+    UNAUTHORIZED = "unauthorized",
+    FORBIDDEN = "forbidden",
+    RATE_LIMIT_EXCEEDED = "rate_limit_exceeded",
+    CONFLICT = "conflict",
+    TIMEOUT = "timeout",
+    NETWORK_ERROR = "network_error",
+    INTERNAL_ERROR = "internal_error",
+    UNKNOWN = "unknown"
+}
+declare class MigmaError extends Error {
+    readonly statusCode: number;
+    readonly code: MigmaErrorCode;
+    constructor(message: string, statusCode: number, code?: MigmaErrorCode);
+    private static codeFromStatus;
+    toJSON(): {
+        name: string;
+        message: string;
+        statusCode: number;
+        code: MigmaErrorCode;
+    };
+}
+
+/** Result type returned by all SDK methods — never throws */
+type MigmaResult<T> = {
+    data: T;
+    error: null;
+} | {
+    data: null;
+    error: MigmaError;
+};
+/** Raw API response envelope from the Migma backend */
+interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    count?: number;
+    message?: string;
+}
+/** Delete response */
+interface DeleteResponse {
+    id: string;
+    deleted: boolean;
+}
+/** Generic message response */
+interface MessageResponse {
+    message: string;
+}
+
+interface ClientConfig {
+    baseUrl: string;
+    timeout: number;
+    maxRetries: number;
+    retryDelay: number;
+}
+type HttpMethod = 'GET' | 'POST' | 'PATCH' | 'PUT' | 'DELETE';
+interface RequestOptions {
+    method: HttpMethod;
+    path: string;
+    body?: Record<string, unknown>;
+    query?: Record<string, string | number | boolean | undefined>;
+    timeout?: number;
+}
+declare class MigmaClient {
+    private readonly apiKey;
+    private readonly config;
+    constructor(apiKey: string, config: ClientConfig);
+    request<T>(options: RequestOptions): Promise<MigmaResult<T>>;
+    /**
+     * For endpoints where the API returns `{ success, data, count }` and we want
+     * both the data array and the count together.
+     */
+    requestWithCount<T>(options: RequestOptions): Promise<MigmaResult<{
+        data: T;
+        count: number;
+    }>>;
+    get<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<MigmaResult<T>>;
+    getWithCount<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<MigmaResult<{
+        data: T;
+        count: number;
+    }>>;
+    post<T>(path: string, body?: Record<string, unknown>): Promise<MigmaResult<T>>;
+    patch<T>(path: string, body?: Record<string, unknown>): Promise<MigmaResult<T>>;
+    put<T>(path: string, body?: Record<string, unknown>): Promise<MigmaResult<T>>;
+    delete<T>(path: string, query?: Record<string, string | number | boolean | undefined>): Promise<MigmaResult<T>>;
+    private buildUrl;
+    private parseRetryAfter;
+    private sleep;
+}
+
+type ContactStatus = 'active' | 'unsubscribed' | 'bounced' | 'complained';
+interface Contact {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    country?: string;
+    language?: string;
+    tags: string[];
+    customFields?: Record<string, unknown>;
+    status: ContactStatus;
+    unsubscribedAt?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateContactParams {
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    /** ISO 3166-1 alpha-2 country code (e.g., US, CA, GB) */
+    country?: string;
+    /** Language code in ISO 639-1 or BCP 47 format (e.g., en, en-US) */
+    language?: string;
+    tags?: string[];
+    customFields?: Record<string, unknown>;
+    projectId: string;
+}
+interface UpdateContactParams {
+    firstName?: string;
+    lastName?: string;
+    country?: string;
+    language?: string;
+    tags?: string[];
+    customFields?: Record<string, unknown>;
+    status?: 'subscribed' | 'unsubscribed' | 'bounced' | 'non-subscribed';
+    projectId: string;
+}
+interface ListContactsParams {
+    projectId: string;
+    page?: number;
+    limit?: number;
+    tags?: string;
+    status?: ContactStatus;
+    search?: string;
+}
+interface ListContactsResponse {
+    data: Contact[];
+    count: number;
+}
+interface BulkImportContactItem {
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    country?: string;
+    language?: string;
+    tags?: string[];
+    customFields?: Record<string, unknown>;
+}
+interface BulkImportParams {
+    subscribers: BulkImportContactItem[];
+    projectId: string;
+}
+interface BulkImportSyncResponse {
+    success: number;
+    failed: number;
+    updated: number;
+    errors?: string[];
+}
+interface BulkImportAsyncResponse {
+    jobId: string;
+    status: 'processing';
+    totalContacts: number;
+    message: string;
+}
+type BulkImportResponse = BulkImportSyncResponse | BulkImportAsyncResponse;
+interface BulkImportJobStatus {
+    jobId: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    totalContacts: number;
+    processed: number;
+    result: BulkImportSyncResponse | null;
+    error: string | null;
+    createdAt: string;
+    completedAt: string | null;
+}
+interface ChangeStatusParams {
+    email: string;
+    status: 'subscribed' | 'unsubscribed' | 'bounced' | 'non-subscribed';
+    allLists?: boolean;
+    tags?: string[];
+    projectId: string;
+}
+
+declare class Contacts {
+    private readonly client;
+    constructor(client: MigmaClient);
+    create(params: CreateContactParams): Promise<MigmaResult<Contact>>;
+    list(params: ListContactsParams): Promise<MigmaResult<ListContactsResponse>>;
+    get(id: string, projectId: string): Promise<MigmaResult<Contact>>;
+    update(id: string, params: UpdateContactParams): Promise<MigmaResult<Contact>>;
+    remove(id: string, projectId: string): Promise<MigmaResult<DeleteResponse>>;
+    bulkImport(params: BulkImportParams): Promise<MigmaResult<BulkImportResponse>>;
+    getBulkImportStatus(jobId: string): Promise<MigmaResult<BulkImportJobStatus>>;
+    changeStatus(params: ChangeStatusParams): Promise<MigmaResult<{
+        success: boolean;
+    }>>;
+}
+
+interface Tag {
+    id: string;
+    name: string;
+    color: string;
+    description: string;
+    subscriberCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateTagParams {
+    name: string;
+    /** Hex color e.g. #FF5733 */
+    color?: string;
+    description?: string;
+    projectId: string;
+}
+interface UpdateTagParams {
+    name?: string;
+    color?: string;
+    description?: string;
+    projectId: string;
+}
+interface ListTagsParams {
+    projectId: string;
+    page?: number;
+    limit?: number;
+    search?: string;
+    sortBy?: 'createdAt' | 'name';
+    sortOrder?: 'asc' | 'desc';
+}
+interface ListTagsResponse {
+    data: Tag[];
+    count: number;
+}
+
+declare class Tags {
+    private readonly client;
+    constructor(client: MigmaClient);
+    list(params: ListTagsParams): Promise<MigmaResult<ListTagsResponse>>;
+    create(params: CreateTagParams): Promise<MigmaResult<Tag>>;
+    get(id: string, projectId: string): Promise<MigmaResult<Tag>>;
+    update(id: string, params: UpdateTagParams): Promise<MigmaResult<Tag>>;
+    remove(id: string, projectId: string): Promise<MigmaResult<DeleteResponse>>;
+}
+
+interface SegmentFilters {
+    tags?: string[];
+    status?: 'subscribed' | 'unsubscribed' | 'non-subscribed' | 'bounced';
+    customFields?: Record<string, string[]>;
+}
+interface Segment {
+    id: string;
+    name: string;
+    description: string;
+    filters: SegmentFilters;
+    count: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateSegmentParams {
+    name: string;
+    description?: string;
+    filters?: SegmentFilters;
+    projectId: string;
+}
+interface UpdateSegmentParams {
+    name?: string;
+    description?: string;
+    filters?: SegmentFilters;
+    projectId: string;
+}
+interface ListSegmentsResponse {
+    data: Segment[];
+    count: number;
+}
+
+declare class Segments {
+    private readonly client;
+    constructor(client: MigmaClient);
+    list(projectId: string): Promise<MigmaResult<ListSegmentsResponse>>;
+    create(params: CreateSegmentParams): Promise<MigmaResult<Segment>>;
+    get(id: string, projectId: string): Promise<MigmaResult<Segment>>;
+    update(id: string, params: UpdateSegmentParams): Promise<MigmaResult<Segment>>;
+    remove(id: string, projectId: string): Promise<MigmaResult<DeleteResponse>>;
+}
+
+interface Topic {
+    id: string;
+    name: string;
+    description: string;
+    defaultSubscription: 'opt_in' | 'opt_out';
+    visibility: 'public' | 'private';
+    displayOrder: number;
+    isActive: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface CreateTopicParams {
+    name: string;
+    description?: string;
+    defaultSubscription?: 'opt_in' | 'opt_out';
+    visibility?: 'public' | 'private';
+    displayOrder?: number;
+    projectId: string;
+}
+interface UpdateTopicParams {
+    name?: string;
+    description?: string;
+    visibility?: 'public' | 'private';
+    displayOrder?: number;
+    isActive?: boolean;
+    projectId: string;
+}
+interface ListTopicsParams {
+    projectId: string;
+    includeInactive?: boolean;
+}
+interface ListTopicsResponse {
+    data: Topic[];
+    count: number;
+}
+interface TopicSubscriptionParams {
+    subscriberId: string;
+    projectId: string;
+}
+interface TopicSubscriptionResponse {
+    topicId: string;
+    subscriberId: string;
+    subscribed: boolean;
+}
+
+declare class Topics {
+    private readonly client;
+    constructor(client: MigmaClient);
+    list(params: ListTopicsParams): Promise<MigmaResult<ListTopicsResponse>>;
+    create(params: CreateTopicParams): Promise<MigmaResult<Topic>>;
+    get(id: string, projectId: string): Promise<MigmaResult<Topic>>;
+    update(id: string, params: UpdateTopicParams): Promise<MigmaResult<Topic>>;
+    remove(id: string, projectId: string): Promise<MigmaResult<DeleteResponse>>;
+    subscribe(topicId: string, params: TopicSubscriptionParams): Promise<MigmaResult<TopicSubscriptionResponse>>;
+    unsubscribe(topicId: string, params: TopicSubscriptionParams): Promise<MigmaResult<TopicSubscriptionResponse>>;
+}
+
+type RecipientType = 'email' | 'audience' | 'segment' | 'tag';
+type ProviderType = 'ses' | 'resend' | 'sendgrid' | 'mailgun' | 'migma';
+interface SendEmailParams {
+    recipientType: RecipientType;
+    /** Required when recipientType is audience, segment, or tag */
+    recipientId?: string;
+    /** Required when recipientType is email */
+    recipientEmail?: string;
+    from: string;
+    fromName: string;
+    replyTo?: string;
+    subject: string;
+    /** HTML template string */
+    template: string;
+    variables?: Record<string, unknown>;
+    providerType?: ProviderType;
+    projectId: string;
+    conversationId?: string;
+}
+interface SendEmailResponse {
+    [key: string]: unknown;
+}
+interface BatchStatus {
+    batchId: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    recipientType: string;
+    recipientId?: string;
+    provider: string;
+    totalCount: number;
+    queuedCount: number;
+    sentCount: number;
+    failedCount: number;
+    from: string;
+    fromName: string;
+    subject: string;
+    createdAt: string;
+    updatedAt?: string;
+    error?: string;
+}
+
+declare class Sending {
+    private readonly client;
+    constructor(client: MigmaClient);
+    send(params: SendEmailParams): Promise<MigmaResult<SendEmailResponse>>;
+    getBatchStatus(batchId: string): Promise<MigmaResult<BatchStatus>>;
+}
+
+interface Project {
+    _id: string;
+    name: string;
+    description: string;
+    status: 'pending' | 'processing' | 'active' | 'error';
+    domain: string;
+    logoUrls?: {
+        primary?: string;
+        secondary?: string;
+        favicon?: string;
+    };
+    screenshotUrl?: string;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
+interface ListProjectsParams {
+    limit?: number;
+    offset?: number;
+    status?: string;
+}
+interface ListProjectsResponse {
+    projects: Project[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    };
+}
+interface ImportProjectParams {
+    urls: string[];
+    logoUrls?: {
+        primary?: string;
+        secondary?: string;
+        favicon?: string;
+    };
+}
+interface ImportProjectResponse {
+    projectId: string;
+    status: 'pending';
+    domain: string;
+    urls: string[];
+    message: string;
+}
+interface ImportStatusResponse {
+    projectId: string;
+    status: 'pending' | 'processing' | 'active' | 'error';
+    name?: string;
+    description?: string;
+    domain?: string;
+    error?: string;
+    progress: {
+        stage: string;
+        percentage: number;
+    };
+    importMetrics?: Record<string, unknown>;
+}
+interface RetryImportResponse {
+    projectId: string;
+    status: string;
+    message: string;
+}
+
+interface PollingOptions {
+    /** Polling interval in ms. Default: 2000 */
+    interval?: number;
+    /** Maximum number of polls before giving up. Default: 150 (5 minutes at 2s) */
+    maxAttempts?: number;
+    /** Callback on each poll with current status */
+    onPoll?: (status: unknown, attempt: number) => void;
+    /** AbortSignal to cancel polling */
+    signal?: AbortSignal;
+}
+/**
+ * Generic polling function.
+ * Calls `fetcher()` repeatedly until `isComplete(result)` returns true
+ * or max attempts are reached.
+ */
+declare function poll<T>(fetcher: () => Promise<MigmaResult<T>>, isComplete: (data: T) => boolean, options?: PollingOptions): Promise<MigmaResult<T>>;
+
+declare class Projects {
+    private readonly client;
+    constructor(client: MigmaClient);
+    list(params?: ListProjectsParams): Promise<MigmaResult<ListProjectsResponse>>;
+    get(projectId: string): Promise<MigmaResult<Project>>;
+    import(params: ImportProjectParams): Promise<MigmaResult<ImportProjectResponse>>;
+    getImportStatus(projectId: string): Promise<MigmaResult<ImportStatusResponse>>;
+    retryImport(projectId: string): Promise<MigmaResult<RetryImportResponse>>;
+    /**
+     * Import a project and wait for completion.
+     * Polls getImportStatus until status is 'active' or 'error'.
+     */
+    importAndWait(params: ImportProjectParams, options?: PollingOptions): Promise<MigmaResult<ImportStatusResponse>>;
+}
+
+interface EmailImage {
+    source: {
+        type: 'url';
+        url: string;
+    };
+}
+interface GenerateEmailParams {
+    projectId: string;
+    prompt: string;
+    images?: EmailImage[];
+    model?: string;
+    webMode?: boolean;
+    languages?: string[];
+    visibility?: 'private' | 'unlisted' | 'public';
+    referenceId?: string;
+}
+interface GenerateEmailResponse {
+    conversationId: string;
+    status: 'pending';
+    message: string;
+    link: string;
+}
+interface EmailGenerationResult {
+    subject: string;
+    previewText: string;
+    html: string;
+    screenshotUrl: string | null;
+    screenshotFullUrl: string | null;
+    stats: {
+        imageCount: number;
+        buttonCount: number;
+        estimatedLength: string;
+        colors: string[];
+    };
+    languages: string[];
+}
+interface EmailGenerationStatus {
+    conversationId: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    createdAt: string;
+    updatedAt: string;
+    error?: string;
+    result?: EmailGenerationResult;
+}
+interface SendTestEmailParams {
+    conversationId: string;
+    to: string;
+}
+interface SendTestEmailResponse {
+    messageId: string;
+    conversationId: string;
+    sentTo: string;
+    sentAt: string;
+    subject: string;
+}
+
+declare class Emails {
+    private readonly client;
+    constructor(client: MigmaClient);
+    /** Start async email generation */
+    generate(params: GenerateEmailParams): Promise<MigmaResult<GenerateEmailResponse>>;
+    /** Check email generation status */
+    getGenerationStatus(conversationId: string): Promise<MigmaResult<EmailGenerationStatus>>;
+    /**
+     * Generate an email and wait for completion.
+     * Polls getGenerationStatus until status is 'completed' or 'failed'.
+     */
+    generateAndWait(params: GenerateEmailParams, options?: PollingOptions): Promise<MigmaResult<EmailGenerationStatus>>;
+    /** Send a test email from a completed conversation */
+    sendTest(params: SendTestEmailParams): Promise<MigmaResult<SendTestEmailResponse>>;
+}
+
+interface CheckCompatibilityParams {
+    html: string;
+    clients?: string[];
+}
+interface CompatibilityResponse {
+    clientIssues: Record<string, unknown>;
+    summary: {
+        totalErrors: number;
+        totalWarnings: number;
+        compatibilityScore: number;
+    };
+    supportedClients: unknown[];
+    metadata: {
+        processingTime: number;
+        clientsTested: number;
+    };
+}
+interface AnalyzeLinksParams {
+    html: string;
+    timeout?: number;
+    followRedirects?: boolean;
+}
+interface CheckedLink {
+    url: string;
+    status: string;
+    responseTime?: number;
+    error?: string;
+}
+interface LinkAnalysisResponse {
+    totalLinks: number;
+    checkedLinks: CheckedLink[];
+    summary: {
+        brokenLinks: number;
+        unreachableLinks: number;
+        averageResponseTime: number;
+    };
+    recommendations: string[];
+    metadata: {
+        processingTime: number;
+        linksChecked: number;
+        linksSkipped: number;
+    };
+}
+interface CheckSpellingParams {
+    html: string;
+    languages?: string[];
+    checkGrammar?: boolean;
+}
+interface SpellingResponse {
+    summary: {
+        totalErrors: number;
+    };
+    metadata: {
+        processingTime: number;
+        aiModel: string;
+        tokensUsed: number;
+    };
+    [key: string]: unknown;
+}
+interface AnalyzeDeliverabilityParams {
+    html: string;
+    subject?: string;
+    fromName?: string;
+    fromEmail?: string;
+}
+interface DeliverabilityResponse {
+    prediction: {
+        category: 'inbox' | 'promotions' | 'spam';
+        confidence: number;
+        score: number;
+        reasoning: string;
+    };
+    contentSignals: {
+        promotional: string[];
+        transactional: string[];
+        spam: string[];
+        engagement: string[];
+    };
+    spamScore: {
+        score: number;
+        triggers: string[];
+        recommendations: string[];
+    };
+    recommendations: {
+        critical: string[];
+        important: string[];
+        suggested: string[];
+    };
+    metadata: {
+        processingTime: number;
+        analysisType: string;
+    };
+}
+interface ValidateAllParams {
+    html: string;
+    subject?: string;
+    options?: {
+        checkCompatibility?: boolean;
+        checkLinks?: boolean;
+        checkSpelling?: boolean;
+        checkDeliverability?: boolean;
+        clients?: string[];
+        languages?: string[];
+    };
+}
+interface ValidateAllResponse {
+    overallScore: number;
+    compatibility?: CompatibilityResponse;
+    linkAnalysis?: LinkAnalysisResponse;
+    spelling?: SpellingResponse;
+    deliverability?: DeliverabilityResponse;
+    summary: {
+        criticalIssues: number;
+        warnings: number;
+        passed: string[];
+        failed: string[];
+    };
+    recommendations: {
+        critical: string[];
+        important: string[];
+        suggested: string[];
+    };
+    metadata: {
+        totalProcessingTime: number;
+        checksPerformed: string[];
+    };
+}
+
+declare class Validation {
+    private readonly client;
+    constructor(client: MigmaClient);
+    all(params: ValidateAllParams): Promise<MigmaResult<ValidateAllResponse>>;
+    compatibility(params: CheckCompatibilityParams): Promise<MigmaResult<CompatibilityResponse>>;
+    links(params: AnalyzeLinksParams): Promise<MigmaResult<LinkAnalysisResponse>>;
+    spelling(params: CheckSpellingParams): Promise<MigmaResult<SpellingResponse>>;
+    deliverability(params: AnalyzeDeliverabilityParams): Promise<MigmaResult<DeliverabilityResponse>>;
+}
+
+type PreviewDeviceStatus = 'PROCESSING' | 'SUCCESSFUL' | 'FAILED';
+type PreviewDeviceCategory = 'DESKTOP' | 'MOBILE' | 'WEB' | 'MISC';
+type PreviewStatus = 'PROCESSING' | 'COMPLETED' | 'PARTIAL_SUCCESS' | 'FAILED';
+interface PreviewDevice {
+    deviceKey: string;
+    deviceName: string;
+    client: string;
+    os: string;
+    category: string;
+    status: PreviewDeviceStatus;
+    screenshotUrl: string | null;
+    thumbnailUrl: string | null;
+    fullThumbnailUrl: string | null;
+    processingTime?: number | null;
+}
+interface PreviewMetadata {
+    requestedDevices: number;
+    completedDevices: number;
+    failedDevices: number;
+    processingDevices: number;
+    processingTime?: number;
+}
+interface CreatePreviewParams {
+    html: string;
+    subject?: string;
+    devices?: string[];
+    name?: string;
+}
+interface CreatePreviewResponse {
+    previewId: string;
+    status: PreviewStatus;
+    devices?: PreviewDevice[];
+    metadata: PreviewMetadata;
+    cached?: boolean;
+}
+interface GetPreviewResponse {
+    previewId: string;
+    status: PreviewStatus;
+    devices: PreviewDevice[];
+    metadata: PreviewMetadata;
+}
+interface GetPreviewStatusResponse {
+    previewId: string;
+    status: PreviewStatus;
+    metadata: PreviewMetadata;
+}
+interface GetDevicePreviewResponse {
+    device: PreviewDevice;
+}
+interface SupportedDevice {
+    key: string;
+    name: string;
+    category: PreviewDeviceCategory;
+}
+interface DeviceCategoriesResponse {
+    desktop: SupportedDevice[];
+    mobile: SupportedDevice[];
+    web: SupportedDevice[];
+    misc: SupportedDevice[];
+}
+interface GetSupportedDevicesResponse {
+    total: number;
+    categories: DeviceCategoriesResponse;
+    devices: SupportedDevice[];
+}
+
+declare class Previews {
+    private readonly client;
+    constructor(client: MigmaClient);
+    create(params: CreatePreviewParams): Promise<MigmaResult<CreatePreviewResponse>>;
+    get(previewId: string): Promise<MigmaResult<GetPreviewResponse>>;
+    getStatus(previewId: string): Promise<MigmaResult<GetPreviewStatusResponse>>;
+    getDevice(previewId: string, deviceKey: string): Promise<MigmaResult<GetDevicePreviewResponse>>;
+    getSupportedDevices(): Promise<MigmaResult<GetSupportedDevicesResponse>>;
+    /**
+     * Create a preview and wait for completion.
+     * Polls getStatus until status is 'COMPLETED', 'PARTIAL_SUCCESS', or 'FAILED'.
+     */
+    createAndWait(params: CreatePreviewParams, options?: PollingOptions): Promise<MigmaResult<GetPreviewResponse>>;
+}
+
+interface ExportFile {
+    filename: string;
+    url: string;
+    format: string;
+}
+interface ExportResult {
+    files: ExportFile[];
+    executionTime: number;
+    exportType: string;
+}
+interface ExportFormat {
+    name: string;
+    description: string;
+    supportedFormats: string[];
+    type: 'simple' | 'complex';
+}
+interface ExportFormatsResponse {
+    formats: ExportFormat[];
+    total: number;
+}
+interface ExportStatusResponse {
+    conversationId: string;
+    canExport: boolean;
+    availableFormats: string[];
+    reason?: string;
+}
+interface HubspotExportParams {
+    conversationId: string;
+    customOptions?: {
+        customInstructions?: string;
+        [key: string]: unknown;
+    };
+}
+
+declare class Export {
+    private readonly client;
+    constructor(client: MigmaClient);
+    getFormats(): Promise<MigmaResult<ExportFormatsResponse>>;
+    getStatus(conversationId: string): Promise<MigmaResult<ExportStatusResponse>>;
+    html(conversationId: string): Promise<MigmaResult<ExportResult>>;
+    mjml(conversationId: string): Promise<MigmaResult<ExportResult>>;
+    pdf(conversationId: string): Promise<MigmaResult<ExportResult>>;
+    klaviyo(conversationId: string, klaviyoType?: 'html' | 'hybrid' | 'code'): Promise<MigmaResult<ExportResult>>;
+    mailchimp(conversationId: string): Promise<MigmaResult<ExportResult>>;
+    hubspot(params: HubspotExportParams): Promise<MigmaResult<ExportResult>>;
+}
+
+interface DnsRecord {
+    type: string;
+    name: string;
+    value: string;
+    priority?: number;
+    status?: string;
+}
+interface Domain {
+    domain: string;
+    region: string;
+    status: string;
+    isVerified?: boolean;
+    dnsRecords?: DnsRecord[];
+    trackingSettings?: {
+        openTracking?: boolean;
+        clickTracking?: boolean;
+        brandedTracking?: boolean;
+    };
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+interface CreateDomainParams {
+    domain: string;
+    region?: 'us-east-1' | 'eu-west-1';
+}
+interface UpdateDomainParams {
+    openTracking?: boolean;
+    clickTracking?: boolean;
+    brandedTracking?: boolean;
+}
+interface DomainVerificationResult {
+    domain: string;
+    status: string;
+    dnsRecords?: DnsRecord[];
+    [key: string]: unknown;
+}
+interface DomainAvailability {
+    available: boolean;
+    [key: string]: unknown;
+}
+interface CreateManagedDomainParams {
+    prefix: string;
+    region?: string;
+}
+interface DomainDeleteResponse {
+    domain: string;
+    deleted: boolean;
+}
+
+declare class Domains {
+    private readonly client;
+    constructor(client: MigmaClient);
+    list(): Promise<MigmaResult<Domain[]>>;
+    create(params: CreateDomainParams): Promise<MigmaResult<Domain>>;
+    get(domain: string): Promise<MigmaResult<Domain>>;
+    verify(domain: string): Promise<MigmaResult<DomainVerificationResult>>;
+    update(domain: string, params: UpdateDomainParams): Promise<MigmaResult<Domain>>;
+    remove(domain: string): Promise<MigmaResult<DomainDeleteResponse>>;
+    checkAvailability(prefix: string): Promise<MigmaResult<DomainAvailability>>;
+    listManaged(): Promise<MigmaResult<Domain[]>>;
+    createManaged(params: CreateManagedDomainParams): Promise<MigmaResult<Domain>>;
+    removeManaged(domain: string): Promise<MigmaResult<DomainDeleteResponse>>;
+}
+
+type WebhookEventType = 'email.generation.started' | 'email.generation.completed' | 'email.generation.failed' | 'email.test.sent' | 'project.import.started' | 'project.import.processing' | 'project.import.completed' | 'project.import.failed' | 'export.completed' | 'export.failed' | 'subscriber.added' | 'subscriber.updated' | 'subscriber.unsubscribed' | 'subscriber.bulk_imported' | 'api_key.created' | 'api_key.revoked';
+interface CreateWebhookParams {
+    url: string;
+    events: WebhookEventType[];
+    description?: string;
+    customHeaders?: Record<string, string>;
+}
+interface UpdateWebhookParams {
+    url?: string;
+    events?: WebhookEventType[];
+    active?: boolean;
+    description?: string;
+    customHeaders?: Record<string, string>;
+}
+interface Webhook {
+    id: string;
+    url: string;
+    events: WebhookEventType[];
+    active: boolean;
+    secret: string;
+    description?: string;
+    createdAt: string;
+}
+interface WebhookDetail extends Webhook {
+    customHeaders?: Record<string, string>;
+    successCount: number;
+    failureCount: number;
+    lastTriggeredAt?: string;
+    updatedAt: string;
+}
+interface ListWebhooksResponse {
+    webhooks: WebhookDetail[];
+    total: number;
+}
+interface WebhookTestResult {
+    success: boolean;
+    statusCode?: number;
+    responseTime?: number;
+    error?: string;
+}
+interface WebhookDelivery {
+    id: string;
+    eventId: string;
+    eventType: WebhookEventType;
+    status: string;
+    attempts: number;
+    lastAttemptAt: string;
+    response: Record<string, unknown>;
+    createdAt: string;
+}
+interface WebhookDeliveriesResponse {
+    deliveries: WebhookDelivery[];
+    total: number;
+}
+interface WebhookEvent {
+    type: WebhookEventType;
+    description: string;
+}
+interface WebhookEventsResponse {
+    events: WebhookEvent[];
+    total: number;
+}
+
+declare class Webhooks {
+    private readonly client;
+    constructor(client: MigmaClient);
+    list(): Promise<MigmaResult<ListWebhooksResponse>>;
+    create(params: CreateWebhookParams): Promise<MigmaResult<Webhook>>;
+    get(webhookId: string): Promise<MigmaResult<WebhookDetail>>;
+    update(webhookId: string, params: UpdateWebhookParams): Promise<MigmaResult<{
+        updated: boolean;
+    }>>;
+    remove(webhookId: string): Promise<MigmaResult<{
+        deleted: boolean;
+    }>>;
+    test(webhookId: string): Promise<MigmaResult<WebhookTestResult>>;
+    getDeliveries(webhookId: string, limit?: number): Promise<MigmaResult<WebhookDeliveriesResponse>>;
+    getEvents(): Promise<MigmaResult<WebhookEventsResponse>>;
+    getStats(): Promise<MigmaResult<Record<string, unknown>>>;
+}
+
+interface KnowledgeBaseEntry {
+    id: string;
+    title: string;
+    content: string;
+    date: string;
+}
+interface KnowledgeBaseListResponse {
+    entries: KnowledgeBaseEntry[];
+    total: number;
+}
+interface AddKnowledgeBaseParams {
+    title: string;
+    content: string;
+}
+interface UpdateKnowledgeBaseParams {
+    title?: string;
+    content?: string;
+}
+
+declare class KnowledgeBase {
+    private readonly client;
+    constructor(client: MigmaClient);
+    list(projectId: string): Promise<MigmaResult<KnowledgeBaseListResponse>>;
+    add(projectId: string, params: AddKnowledgeBaseParams): Promise<MigmaResult<KnowledgeBaseEntry>>;
+    update(projectId: string, entryId: string, params: UpdateKnowledgeBaseParams): Promise<MigmaResult<KnowledgeBaseEntry>>;
+    remove(projectId: string, entryId: string): Promise<MigmaResult<MessageResponse>>;
+}
+
+interface ProjectImage {
+    url: string;
+    description?: string;
+    tags?: string[];
+    [key: string]: unknown;
+}
+interface AddImageParams {
+    url: string;
+    description?: string;
+    tags?: string[];
+}
+interface UpdateImageParams {
+    imageUrl: string;
+    description?: string;
+    tags?: string[];
+}
+interface UpdateLogosParams {
+    primary?: string | null;
+    secondary?: string | null;
+    favicon?: string | null;
+}
+interface LogosResponse {
+    logoUrls: {
+        primary?: string;
+        secondary?: string;
+        favicon?: string;
+    };
+}
+
+declare class Images {
+    private readonly client;
+    constructor(client: MigmaClient);
+    add(projectId: string, params: AddImageParams): Promise<MigmaResult<ProjectImage>>;
+    update(projectId: string, params: UpdateImageParams): Promise<MigmaResult<ProjectImage>>;
+    remove(projectId: string, imageUrl: string): Promise<MigmaResult<MessageResponse>>;
+    updateLogos(projectId: string, params: UpdateLogosParams): Promise<MigmaResult<LogosResponse>>;
+}
+
+interface MigmaConfig {
+    /** API base URL. Default: 'https://api.migma.ai/api/v1' */
+    baseUrl?: string;
+    /** Request timeout in ms. Default: 30000 */
+    timeout?: number;
+    /** Max retries on 5xx/429 errors. Default: 2 */
+    maxRetries?: number;
+    /** Base delay between retries in ms. Default: 1000 */
+    retryDelay?: number;
+}
+declare class Migma {
+    private readonly client;
+    readonly contacts: Contacts;
+    readonly tags: Tags;
+    readonly segments: Segments;
+    readonly topics: Topics;
+    readonly sending: Sending;
+    readonly projects: Projects;
+    readonly emails: Emails;
+    readonly validation: Validation;
+    readonly previews: Previews;
+    readonly export: Export;
+    readonly domains: Domains;
+    readonly webhooks: Webhooks;
+    readonly knowledgeBase: KnowledgeBase;
+    readonly images: Images;
+    constructor(apiKey: string, config?: MigmaConfig);
+}
+
+export { type AddImageParams, type AddKnowledgeBaseParams, type AnalyzeDeliverabilityParams, type AnalyzeLinksParams, type ApiResponse, type BatchStatus, type BulkImportAsyncResponse, type BulkImportContactItem, type BulkImportJobStatus, type BulkImportParams, type BulkImportResponse, type BulkImportSyncResponse, type ChangeStatusParams, type CheckCompatibilityParams, type CheckSpellingParams, type CheckedLink, type ClientConfig, type CompatibilityResponse, type Contact, type ContactStatus, type CreateContactParams, type CreateDomainParams, type CreateManagedDomainParams, type CreatePreviewParams, type CreatePreviewResponse, type CreateSegmentParams, type CreateTagParams, type CreateTopicParams, type CreateWebhookParams, type DeleteResponse, type DeliverabilityResponse, type DeviceCategoriesResponse, type DnsRecord, type Domain, type DomainAvailability, type DomainDeleteResponse, type DomainVerificationResult, type EmailGenerationResult, type EmailGenerationStatus, type EmailImage, type ExportFile, type ExportFormat, type ExportFormatsResponse, type ExportResult, type ExportStatusResponse, type GenerateEmailParams, type GenerateEmailResponse, type GetDevicePreviewResponse, type GetPreviewResponse, type GetPreviewStatusResponse, type GetSupportedDevicesResponse, type HubspotExportParams, type ImportProjectParams, type ImportProjectResponse, type ImportStatusResponse, type KnowledgeBaseEntry, type KnowledgeBaseListResponse, type LinkAnalysisResponse, type ListContactsParams, type ListContactsResponse, type ListProjectsParams, type ListProjectsResponse, type ListSegmentsResponse, type ListTagsParams, type ListTagsResponse, type ListTopicsParams, type ListTopicsResponse, type ListWebhooksResponse, type LogosResponse, type MessageResponse, Migma, MigmaClient, type MigmaConfig, MigmaError, MigmaErrorCode, type MigmaResult, type PollingOptions, type PreviewDevice, type PreviewDeviceCategory, type PreviewDeviceStatus, type PreviewMetadata, type PreviewStatus, type Project, type ProjectImage, type ProviderType, type RecipientType, type RetryImportResponse, type Segment, type SegmentFilters, type SendEmailParams, type SendEmailResponse, type SendTestEmailParams, type SendTestEmailResponse, type SpellingResponse, type SupportedDevice, type Tag, type Topic, type TopicSubscriptionParams, type TopicSubscriptionResponse, type UpdateContactParams, type UpdateDomainParams, type UpdateImageParams, type UpdateKnowledgeBaseParams, type UpdateLogosParams, type UpdateSegmentParams, type UpdateTagParams, type UpdateTopicParams, type UpdateWebhookParams, type ValidateAllParams, type ValidateAllResponse, type Webhook, type WebhookDeliveriesResponse, type WebhookDelivery, type WebhookDetail, type WebhookEvent, type WebhookEventType, type WebhookEventsResponse, type WebhookTestResult, poll };