shipmail 0.1.20 → 0.1.22

package/dist/index.d.ts

@@ -59,7 +59,7 @@ type StatusResponse = {
 };
 declare const DOMAIN_STATUSES: readonly ["pending", "verifying", "verified", "degraded", "failed"];
 type DomainStatus = (typeof DOMAIN_STATUSES)[number];
-declare const MESSAGE_STATUSES: readonly ["queued", "sent", "delivered", "bounced", "complained", "failed"];
+declare const MESSAGE_STATUSES: readonly ["scheduled", "queued", "sent", "delivered", "bounced", "complained", "failed", "cancelled"];
 type MessageStatus = (typeof MESSAGE_STATUSES)[number];
 declare const MESSAGE_SOURCES: readonly ["api", "dashboard", "inbound", "smtp"];
 type MessageSource = (typeof MESSAGE_SOURCES)[number];
@@ -95,7 +95,7 @@ type CreateDomainParams = {
     readonly name: string;
 };
 type UpdateDomainParams = {
-    readonly catch_all_mailbox_id?: string | null | undefined;
+    readonly catch_all_mailbox_id: string | null;
 };
 type ListDomainsParams = PaginationParams;
 type DomainVerificationResult = {
@@ -167,6 +167,100 @@ declare class Domains extends ApiResource {
     register(params: RegisterDomainParams, options?: MethodOptions): Promise<Domain>;
 }
 
+declare const MAILBOX_IMPORT_STATUSES: readonly ["queued", "running", "paused_throttle", "paused_quota", "completed", "failed", "cancelled", "undo_queued", "undoing", "undone", "undo_failed"];
+type MailboxImportStatus = (typeof MAILBOX_IMPORT_STATUSES)[number];
+declare const MAILBOX_IMPORT_PROVIDERS: readonly ["gmail", "outlook", "yahoo", "aol", "icloud", "fastmail", "zoho", "imap", "takeout", "proton", "tuta", "file"];
+type MailboxImportProvider = (typeof MAILBOX_IMPORT_PROVIDERS)[number];
+declare const MAILBOX_IMPORT_IMAP_PROVIDERS: readonly ["gmail", "yahoo", "aol", "icloud", "fastmail", "zoho", "imap"];
+type MailboxImportImapProvider = (typeof MAILBOX_IMPORT_IMAP_PROVIDERS)[number];
+declare const MAILBOX_IMPORT_FILE_PROVIDERS: readonly ["takeout", "proton", "tuta", "file"];
+type MailboxImportFileProvider = (typeof MAILBOX_IMPORT_FILE_PROVIDERS)[number];
+declare const MAILBOX_IMPORT_FOLDER_STATES: readonly ["pending", "importing", "completed", "failed"];
+type MailboxImportFolderState = (typeof MAILBOX_IMPORT_FOLDER_STATES)[number];
+declare const MAILBOX_IMPORT_RANGES: readonly ["all", "12m", "3m", "1m"];
+type MailboxImportRange = (typeof MAILBOX_IMPORT_RANGES)[number];
+type MailboxImportKind = "imap" | "file";
+type MailboxImportCounts = {
+    readonly found: number;
+    readonly imported: number;
+    readonly undone: number;
+    readonly duplicates_skipped: number;
+    readonly oversize_skipped: number;
+    readonly failed: number;
+    readonly contacts_imported: number;
+};
+type MailboxImportBytes = {
+    readonly total: number;
+    readonly imported: number;
+};
+type MailboxImportFolder = {
+    readonly source_folder: string;
+    readonly target_folder: string | null;
+    readonly role: string | null;
+    readonly state: MailboxImportFolderState;
+    readonly found: number;
+    readonly imported: number;
+    readonly duplicates: number;
+    readonly oversize: number;
+    readonly failed: number;
+};
+type MailboxImport = {
+    readonly object: "import";
+    readonly id: string;
+    readonly mailbox_id: string;
+    readonly kind: MailboxImportKind;
+    readonly provider: MailboxImportProvider;
+    readonly source_address: string | null;
+    readonly status: MailboxImportStatus;
+    readonly status_detail: string | null;
+    readonly error: string | null;
+    readonly resume_at: string | null;
+    readonly counts: MailboxImportCounts;
+    readonly bytes: MailboxImportBytes;
+    readonly created_at: string;
+    readonly started_at: string | null;
+    readonly completed_at: string | null;
+    readonly folders?: readonly MailboxImportFolder[] | undefined;
+};
+type MailboxImports = {
+    readonly object: "imports";
+    readonly mailbox_id: string;
+    readonly data: readonly MailboxImport[];
+};
+type MailboxImportImapSource = {
+    readonly type: "imap";
+    readonly provider: MailboxImportImapProvider;
+    readonly email: string;
+    readonly password: string;
+    readonly host?: string | undefined;
+    readonly port?: number | undefined;
+};
+type MailboxImportFileSource = {
+    readonly type: "files";
+    readonly provider: MailboxImportFileProvider;
+    readonly file_ids: readonly string[];
+};
+type MailboxImportOptions = {
+    readonly folders?: readonly string[] | null | undefined;
+    readonly range?: MailboxImportRange | undefined;
+    readonly include_spam?: boolean | undefined;
+    readonly include_trash?: boolean | undefined;
+};
+type CreateMailboxImportParams = {
+    readonly source: MailboxImportImapSource | MailboxImportFileSource;
+    readonly options?: MailboxImportOptions | undefined;
+};
+type CreateImportUploadParams = {
+    readonly file_name: string;
+    readonly size_bytes: number;
+};
+type ImportUpload = {
+    readonly object: "import_upload";
+    readonly file_id: string;
+    readonly upload_url: string;
+    readonly expires_in_seconds: number;
+};
+
 type AutoReply = {
     readonly enabled: boolean;
     readonly subject: string | null;
@@ -181,10 +275,173 @@ type Mailbox = {
     readonly address: string;
     readonly display_name: string | null;
     readonly suspended_at: string | null;
+    readonly spam_filter_threshold: number;
     readonly auto_reply: AutoReply;
     readonly created_at: string;
     readonly updated_at: string;
 };
+type MailboxFolder = {
+    readonly object: "mailbox_folder";
+    readonly id: string;
+    readonly name: string;
+    readonly parent_id: string | null;
+    readonly role: string | null;
+    readonly kind: "custom" | "system";
+    readonly total_emails: number;
+    readonly unread_emails: number;
+    readonly unread_threads: number;
+    readonly sort_order: number;
+};
+type MailboxFolders = {
+    readonly object: "mailbox_folders";
+    readonly mailbox_id: string;
+    readonly address: string;
+    readonly data: readonly MailboxFolder[];
+};
+type MailboxIdentity = {
+    readonly object: "mailbox_identity";
+    readonly id: string;
+    readonly name: string;
+    readonly email: string;
+};
+type MailboxIdentities = {
+    readonly object: "mailbox_identities";
+    readonly mailbox_id: string;
+    readonly address: string;
+    readonly data: readonly MailboxIdentity[];
+};
+type InboxEmailHeader = {
+    readonly name: string | null;
+    readonly email: string | null;
+};
+type InboxKeyword = "$flagged" | "$seen" | "$draft" | "$answered" | "$forwarded";
+type InboxAttachment = {
+    readonly part_id: string;
+    readonly blob_id: string;
+    readonly name: string | null;
+    readonly content_type: string;
+    readonly size: number;
+    readonly download_path: string;
+};
+type InboxBodyPart = {
+    readonly part_id: string;
+    readonly type: string;
+};
+type InboxBodyValue = {
+    readonly value: string;
+    readonly is_encoding_problem: boolean;
+};
+type InboxMessage = {
+    readonly object: "inbox_message";
+    readonly id: string;
+    readonly thread_id: string;
+    readonly mailbox_id: string;
+    readonly address: string;
+    readonly folder_ids: readonly string[];
+    readonly keywords: Readonly<Record<string, boolean>>;
+    readonly from: readonly InboxEmailHeader[] | null;
+    readonly to: readonly InboxEmailHeader[] | null;
+    readonly subject: string | null;
+    readonly received_at: string;
+    readonly preview: string;
+    readonly has_attachment: boolean;
+    readonly size: number;
+};
+type InboxFullMessage = Omit<InboxMessage, "object"> & {
+    readonly object: "inbox_message_full";
+    readonly cc: readonly InboxEmailHeader[] | null;
+    readonly reply_to: readonly InboxEmailHeader[] | null;
+    readonly message_id: readonly string[] | null;
+    readonly in_reply_to: readonly string[] | null;
+    readonly references: readonly string[] | null;
+    readonly body_values: Readonly<Record<string, InboxBodyValue>>;
+    readonly text_body: readonly InboxBodyPart[];
+    readonly html_body: readonly InboxBodyPart[];
+    readonly attachments: readonly InboxAttachment[];
+};
+type InboxMessages = {
+    readonly object: "inbox_messages";
+    readonly mailbox_id: string;
+    readonly address: string;
+    readonly data: readonly InboxMessage[];
+    readonly pagination: {
+        readonly position: number;
+        readonly limit: number;
+        readonly total: number;
+        readonly has_more: boolean;
+        readonly next_position: number | null;
+    };
+};
+type InboxThread = {
+    readonly object: "inbox_thread";
+    readonly mailbox_id: string;
+    readonly address: string;
+    readonly thread_id: string;
+    readonly data: readonly InboxFullMessage[];
+};
+type InboxMessageAction = {
+    readonly object: "inbox_message_action";
+    readonly mailbox_id: string;
+    readonly address: string;
+    readonly message_id: string;
+    readonly ok: true;
+};
+type MailboxRuleMatchMode = "all" | "any";
+type MailboxRuleCondition = {
+    readonly type: "from_is" | "from_contains" | "recipient_is" | "plus_tag_is" | "subject_contains";
+    readonly value: string;
+} | {
+    readonly type: "has_attachment" | "list_unsubscribe_exists";
+} | {
+    readonly type: "group";
+    readonly match_mode: MailboxRuleMatchMode;
+    readonly conditions: readonly MailboxRuleCondition[];
+};
+type MailboxRuleMoveTarget = {
+    readonly kind: "system";
+    readonly role: "inbox" | "archive" | "junk" | "trash";
+} | {
+    readonly kind: "custom";
+    readonly folder_id: string;
+};
+type MailboxRuleAction = {
+    readonly type: "move";
+    readonly target: MailboxRuleMoveTarget;
+} | {
+    readonly type: "mark_read";
+} | {
+    readonly type: "star";
+} | {
+    readonly type: "send_webhook";
+} | {
+    readonly type: "ai_draft_reply";
+    readonly instructions: string;
+    readonly reply_mode: "reply" | "reply_all";
+};
+type MailboxRule = {
+    readonly id: string;
+    readonly name: string;
+    readonly enabled: boolean;
+    readonly position: number;
+    readonly match_mode: MailboxRuleMatchMode;
+    readonly stop: boolean;
+    readonly conditions: readonly MailboxRuleCondition[];
+    readonly actions: readonly MailboxRuleAction[];
+};
+type MailboxRuleFolder = {
+    readonly id: string;
+    readonly name: string;
+    readonly parent_id: string | null;
+    readonly role: string | null;
+    readonly kind: "custom" | "system";
+};
+type MailboxRules = {
+    readonly object: "mailbox_rules";
+    readonly mailbox_id: string;
+    readonly address: string;
+    readonly rules: readonly MailboxRule[];
+    readonly folders: readonly MailboxRuleFolder[];
+};
 type CreateMailboxParams = {
     readonly domain_id: string;
     readonly address: string;
@@ -193,9 +450,41 @@ type CreateMailboxParams = {
 type UpdateMailboxParams = {
     readonly display_name?: string | null | undefined;
 };
+type CreateMailboxFolderParams = {
+    readonly name: string;
+    readonly parent_id: string | null;
+};
+type UpdateMailboxFolderParams = {
+    readonly name: string;
+};
+type ResetMailboxPasswordParams = {
+    readonly password: string;
+};
 type ListMailboxesParams = PaginationParams & {
     readonly domain_id?: string | undefined;
 };
+type ListInboxMessagesParams = {
+    readonly folder_id?: string | undefined;
+    readonly folder_role?: "inbox" | "starred" | "sent" | "drafts" | "archive" | "junk" | "trash" | undefined;
+    readonly search_text?: string | undefined;
+    readonly position?: number | undefined;
+    readonly limit?: number | undefined;
+    readonly has_keyword?: InboxKeyword | undefined;
+    readonly not_keyword?: InboxKeyword | undefined;
+};
+type DownloadInboxAttachmentParams = {
+    readonly blob_id: string;
+    readonly name?: string | undefined;
+};
+type UpdateInboxMessageParams = {
+    readonly read?: boolean | undefined;
+    readonly starred?: boolean | undefined;
+};
+type MoveInboxMessageParams = {
+    readonly from_folder_id?: string | undefined;
+    readonly target_role?: "inbox" | "archive" | "junk" | "trash" | undefined;
+    readonly target_folder_id?: string | undefined;
+};
 type UpdateAutoReplyParams = {
     readonly enabled: boolean;
     readonly subject?: string | null | undefined;
@@ -203,6 +492,12 @@ type UpdateAutoReplyParams = {
     readonly from_date?: string | null | undefined;
     readonly to_date?: string | null | undefined;
 };
+type UpdateSpamFilterParams = {
+    readonly threshold: number;
+};
+type UpdateMailboxRulesParams = {
+    readonly rules: readonly MailboxRule[];
+};
 
 declare class Mailboxes extends ApiResource {
     create(params: CreateMailboxParams, options?: MethodOptions): Promise<Mailbox>;
@@ -211,7 +506,28 @@ declare class Mailboxes extends ApiResource {
     get(id: string, options?: MethodOptions): Promise<Mailbox>;
     update(id: string, params: UpdateMailboxParams, options?: MethodOptions): Promise<Mailbox>;
     delete(id: string, options?: MethodOptions): Promise<void>;
+    listFolders(id: string, options?: MethodOptions): Promise<MailboxFolders>;
+    createFolder(id: string, params: CreateMailboxFolderParams, options?: MethodOptions): Promise<MailboxFolder>;
+    updateFolder(id: string, folderId: string, params: UpdateMailboxFolderParams, options?: MethodOptions): Promise<MailboxFolder>;
+    deleteFolder(id: string, folderId: string, options?: MethodOptions): Promise<void>;
+    listIdentities(id: string, options?: MethodOptions): Promise<MailboxIdentities>;
+    listInboxMessages(id: string, params?: ListInboxMessagesParams, options?: MethodOptions): Promise<InboxMessages>;
+    getInboxThread(id: string, threadId: string, options?: MethodOptions): Promise<InboxThread>;
+    updateInboxMessage(id: string, messageId: string, params: UpdateInboxMessageParams, options?: MethodOptions): Promise<InboxMessageAction>;
+    moveInboxMessage(id: string, messageId: string, params: MoveInboxMessageParams, options?: MethodOptions): Promise<InboxMessageAction>;
+    deleteInboxMessage(id: string, messageId: string, options?: MethodOptions): Promise<void>;
+    downloadInboxAttachment(id: string, params: DownloadInboxAttachmentParams, options?: MethodOptions): Promise<Uint8Array>;
+    resetPassword(id: string, params: ResetMailboxPasswordParams, options?: MethodOptions): Promise<Mailbox>;
+    getRules(id: string, options?: MethodOptions): Promise<MailboxRules>;
+    updateRules(id: string, params: UpdateMailboxRulesParams, options?: MethodOptions): Promise<MailboxRules>;
     updateAutoReply(id: string, params: UpdateAutoReplyParams, options?: MethodOptions): Promise<Mailbox>;
+    updateSpamFilter(id: string, params: UpdateSpamFilterParams, options?: MethodOptions): Promise<Mailbox>;
+    createImport(id: string, params: CreateMailboxImportParams, options?: MethodOptions): Promise<MailboxImport>;
+    listImports(id: string, options?: MethodOptions): Promise<MailboxImports>;
+    getImport(id: string, importId: string, options?: MethodOptions): Promise<MailboxImport>;
+    cancelImport(id: string, importId: string, options?: MethodOptions): Promise<MailboxImport>;
+    undoImport(id: string, importId: string, options?: MethodOptions): Promise<MailboxImport>;
+    createImportUpload(id: string, params: CreateImportUploadParams, options?: MethodOptions): Promise<ImportUpload>;
 }
 
 type Message = {
@@ -240,6 +556,7 @@ type Message = {
     }[] | null;
     readonly source: MessageSource;
     readonly status: MessageStatus;
+    readonly scheduled_at: string | null;
     readonly created_at: string;
     readonly updated_at: string;
 };
@@ -261,6 +578,7 @@ type SendMessageParams = {
     readonly in_reply_to?: string | undefined;
     readonly references?: readonly string[] | undefined;
     readonly attachments?: readonly Attachment[] | undefined;
+    readonly scheduled_at?: string | undefined;
 };
 type ListMessagesParams = PaginationParams & {
     readonly mailbox_id: string;
@@ -270,6 +588,7 @@ type ReplyToMessageParams = {
     readonly text?: string | undefined;
     readonly to: readonly EmailRecipientInput[];
     readonly cc?: readonly EmailRecipientInput[] | undefined;
+    readonly scheduled_at?: string | undefined;
 };
 
 declare class Messages extends ApiResource {
@@ -301,6 +620,16 @@ declare class Suppressions extends ApiResource {
     remove(email: string, options?: MethodOptions): Promise<void>;
 }
 
+type Thread = {
+    readonly object: "thread";
+    readonly id: string;
+    readonly mailbox_id: string;
+    readonly subject: string | null;
+    readonly message_count: number;
+    readonly latest_message: Message;
+    readonly created_at: string;
+    readonly updated_at: string;
+};
 type ListThreadsParams = PaginationParams & {
     readonly mailbox_id: string;
 };
@@ -310,11 +639,12 @@ type ReplyToThreadParams = {
     readonly text?: string | undefined;
     readonly to?: readonly EmailRecipientInput[] | undefined;
     readonly cc?: readonly EmailRecipientInput[] | undefined;
+    readonly scheduled_at?: string | undefined;
 };
 
 declare class Threads extends ApiResource {
-    list(params: ListThreadsParams, options?: MethodOptions): Promise<PaginatedResponse<Message>>;
-    listAutoPaginating(params: Omit<ListThreadsParams, "cursor">): Page<Message>;
+    list(params: ListThreadsParams, options?: MethodOptions): Promise<PaginatedResponse<Thread>>;
+    listAutoPaginating(params: Omit<ListThreadsParams, "cursor">): Page<Thread>;
     get(id: string, params?: GetThreadParams, options?: MethodOptions): Promise<PaginatedResponse<Message>>;
     reply(id: string, params: ReplyToThreadParams, options?: MethodOptions): Promise<Message>;
 }
@@ -419,6 +749,8 @@ declare class ShipMailClient {
      */
     constructor(config: string | ShipMailConfig);
     request<T>(options: RequestOptions): Promise<T>;
+    requestBytes(options: RequestOptions): Promise<Uint8Array>;
+    private requestWithParser;
     private buildUrl;
 }
 
@@ -493,4 +825,4 @@ declare function verifyWebhook(body: string, headers: WebhookHeaders | Headers,
     readonly toleranceInSeconds?: number | undefined;
 }): Promise<WebhookEvent>;
 
-export { type ApiErrorBody, AuthenticationError, AuthorizationError, ConflictError, ConnectionError, type CreateDomainParams, type CreateMailboxParams, type CreateWebhookParams, DOMAIN_STATUSES, type Domain, type DomainRegistrationInfo, type DomainSearchResult, type DomainStatus, type DomainVerificationResult, type EmailRecipient, type EmailRecipientInput, type ErrorType, type GetThreadParams, InternalServerError, type ListDeliveriesParams, type ListDomainsParams, type ListMailboxesParams, type ListMessagesParams, type ListSuppressionsParams, type ListThreadsParams, type ListWebhooksParams, MESSAGE_SOURCES, MESSAGE_STATUSES, type Mailbox, type Message, type MessageSource, type MessageStatus, type MethodOptions, NotFoundError, Page, type PaginatedResponse, type PaginationParams, QuotaExceededError, RateLimitError, type RegisterDomainParams, type RegistrationContact, type ReplyToMessageParams, type ReplyToThreadParams, type RequestOptions, type RotateSecretResponse, type SearchDomainsParams, type SendMessageParams, ShipMailClient, type ShipMailConfig, ShipMailError, type StatusResponse, type Suppression, type TestWebhookResponse, type UpdateAutoReplyParams, type UpdateDomainParams, type UpdateMailboxParams, type UpdateWebhookParams, ValidationError, WEBHOOK_DELIVERY_STATUSES, WEBHOOK_EVENT_TYPES, type Webhook, type WebhookDelivery, type WebhookDeliveryStatus, type WebhookEvent, type WebhookEventType, WebhookVerificationError, type WebhookWithSecret, ShipMailClient as default, verifyWebhook };
+export { type ApiErrorBody, AuthenticationError, AuthorizationError, ConflictError, ConnectionError, type CreateDomainParams, type CreateMailboxFolderParams, type CreateMailboxParams, type CreateWebhookParams, DOMAIN_STATUSES, type Domain, type DomainRegistrationInfo, type DomainSearchResult, type DomainStatus, type DomainVerificationResult, type DownloadInboxAttachmentParams, type EmailRecipient, type EmailRecipientInput, type ErrorType, type GetThreadParams, type InboxAttachment, type InboxBodyPart, type InboxBodyValue, type InboxEmailHeader, type InboxFullMessage, type InboxKeyword, type InboxMessage, type InboxMessageAction, type InboxMessages, type InboxThread, InternalServerError, type ListDeliveriesParams, type ListDomainsParams, type ListInboxMessagesParams, type ListMailboxesParams, type ListMessagesParams, type ListSuppressionsParams, type ListThreadsParams, type ListWebhooksParams, MESSAGE_SOURCES, MESSAGE_STATUSES, type Mailbox, type MailboxFolder, type MailboxFolders, type MailboxIdentities, type MailboxIdentity, type MailboxRule, type MailboxRuleAction, type MailboxRuleCondition, type MailboxRuleFolder, type MailboxRuleMatchMode, type MailboxRuleMoveTarget, type MailboxRules, type Message, type MessageSource, type MessageStatus, type MethodOptions, type MoveInboxMessageParams, NotFoundError, Page, type PaginatedResponse, type PaginationParams, QuotaExceededError, RateLimitError, type RegisterDomainParams, type RegistrationContact, type ReplyToMessageParams, type ReplyToThreadParams, type RequestOptions, type ResetMailboxPasswordParams, type RotateSecretResponse, type SearchDomainsParams, type SendMessageParams, ShipMailClient, type ShipMailConfig, ShipMailError, type StatusResponse, type Suppression, type TestWebhookResponse, type Thread, type UpdateAutoReplyParams, type UpdateDomainParams, type UpdateInboxMessageParams, type UpdateMailboxFolderParams, type UpdateMailboxParams, type UpdateMailboxRulesParams, type UpdateSpamFilterParams, type UpdateWebhookParams, ValidationError, WEBHOOK_DELIVERY_STATUSES, WEBHOOK_EVENT_TYPES, type Webhook, type WebhookDelivery, type WebhookDeliveryStatus, type WebhookEvent, type WebhookEventType, WebhookVerificationError, type WebhookWithSecret, ShipMailClient as default, verifyWebhook };

package/dist/index.js

@@ -265,6 +265,123 @@ var Mailboxes = class extends ApiResource {
       methodOptions: options
     });
   }
+  listFolders(id, options) {
+    return this.client.request({
+      method: "GET",
+      path: `/mailboxes/${encodeURIComponent(id)}/folders`,
+      methodOptions: options
+    });
+  }
+  createFolder(id, params, options) {
+    return this.client.request({
+      method: "POST",
+      path: `/mailboxes/${encodeURIComponent(id)}/folders`,
+      body: params,
+      methodOptions: options
+    });
+  }
+  updateFolder(id, folderId, params, options) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/mailboxes/${encodeURIComponent(id)}/folders/${encodeURIComponent(folderId)}`,
+      body: params,
+      methodOptions: options
+    });
+  }
+  deleteFolder(id, folderId, options) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/mailboxes/${encodeURIComponent(id)}/folders/${encodeURIComponent(folderId)}`,
+      methodOptions: options
+    });
+  }
+  listIdentities(id, options) {
+    return this.client.request({
+      method: "GET",
+      path: `/mailboxes/${encodeURIComponent(id)}/identities`,
+      methodOptions: options
+    });
+  }
+  listInboxMessages(id, params, options) {
+    return this.client.request({
+      method: "GET",
+      path: `/mailboxes/${encodeURIComponent(id)}/inbox/messages`,
+      query: {
+        folder_id: params?.folder_id,
+        folder_role: params?.folder_role,
+        search_text: params?.search_text,
+        position: params?.position,
+        limit: params?.limit,
+        has_keyword: params?.has_keyword,
+        not_keyword: params?.not_keyword
+      },
+      methodOptions: options
+    });
+  }
+  getInboxThread(id, threadId, options) {
+    return this.client.request({
+      method: "GET",
+      path: `/mailboxes/${encodeURIComponent(id)}/inbox/threads/${encodeURIComponent(threadId)}`,
+      methodOptions: options
+    });
+  }
+  updateInboxMessage(id, messageId, params, options) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/mailboxes/${encodeURIComponent(id)}/inbox/messages/${encodeURIComponent(messageId)}`,
+      body: params,
+      methodOptions: options
+    });
+  }
+  moveInboxMessage(id, messageId, params, options) {
+    return this.client.request({
+      method: "POST",
+      path: `/mailboxes/${encodeURIComponent(id)}/inbox/messages/${encodeURIComponent(messageId)}/move`,
+      body: params,
+      methodOptions: options
+    });
+  }
+  deleteInboxMessage(id, messageId, options) {
+    return this.client.request({
+      method: "DELETE",
+      path: `/mailboxes/${encodeURIComponent(id)}/inbox/messages/${encodeURIComponent(messageId)}`,
+      methodOptions: options
+    });
+  }
+  downloadInboxAttachment(id, params, options) {
+    return this.client.requestBytes({
+      method: "GET",
+      path: `/mailboxes/${encodeURIComponent(id)}/inbox/attachments`,
+      query: {
+        blob_id: params.blob_id,
+        name: params.name
+      },
+      methodOptions: options
+    });
+  }
+  resetPassword(id, params, options) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/mailboxes/${encodeURIComponent(id)}/password`,
+      body: params,
+      methodOptions: options
+    });
+  }
+  getRules(id, options) {
+    return this.client.request({
+      method: "GET",
+      path: `/mailboxes/${encodeURIComponent(id)}/rules`,
+      methodOptions: options
+    });
+  }
+  updateRules(id, params, options) {
+    return this.client.request({
+      method: "PUT",
+      path: `/mailboxes/${encodeURIComponent(id)}/rules`,
+      body: params,
+      methodOptions: options
+    });
+  }
   updateAutoReply(id, params, options) {
     return this.client.request({
       method: "PATCH",
@@ -273,6 +390,58 @@ var Mailboxes = class extends ApiResource {
       methodOptions: options
     });
   }
+  updateSpamFilter(id, params, options) {
+    return this.client.request({
+      method: "PATCH",
+      path: `/mailboxes/${encodeURIComponent(id)}/spam-filter`,
+      body: params,
+      methodOptions: options
+    });
+  }
+  createImport(id, params, options) {
+    return this.client.request({
+      method: "POST",
+      path: `/mailboxes/${encodeURIComponent(id)}/imports`,
+      body: params,
+      methodOptions: options
+    });
+  }
+  listImports(id, options) {
+    return this.client.request({
+      method: "GET",
+      path: `/mailboxes/${encodeURIComponent(id)}/imports`,
+      methodOptions: options
+    });
+  }
+  getImport(id, importId, options) {
+    return this.client.request({
+      method: "GET",
+      path: `/mailboxes/${encodeURIComponent(id)}/imports/${encodeURIComponent(importId)}`,
+      methodOptions: options
+    });
+  }
+  cancelImport(id, importId, options) {
+    return this.client.request({
+      method: "POST",
+      path: `/mailboxes/${encodeURIComponent(id)}/imports/${encodeURIComponent(importId)}/cancel`,
+      methodOptions: options
+    });
+  }
+  undoImport(id, importId, options) {
+    return this.client.request({
+      method: "POST",
+      path: `/mailboxes/${encodeURIComponent(id)}/imports/${encodeURIComponent(importId)}/undo`,
+      methodOptions: options
+    });
+  }
+  createImportUpload(id, params, options) {
+    return this.client.request({
+      method: "POST",
+      path: `/mailboxes/${encodeURIComponent(id)}/imports/files`,
+      body: params,
+      methodOptions: options
+    });
+  }
 };
 
 // src/resources/messages.ts
@@ -488,7 +657,7 @@ var Webhooks = class extends ApiResource {
 };
 
 // src/version.ts
-var VERSION = "0.1.20";
+var VERSION = "0.1.22";
 
 // src/client.ts
 var DEFAULT_BASE_URL = "https://shipmail.to/api/v1";
@@ -542,6 +711,19 @@ var ShipMailClient = class {
     this.status = new Status(this);
   }
   async request(options) {
+    return this.requestWithParser(options, "application/json", async (response) => {
+      if (response.status === 204) {
+        return void 0;
+      }
+      return await response.json();
+    });
+  }
+  async requestBytes(options) {
+    return this.requestWithParser(options, "application/octet-stream", async (response) => {
+      return new Uint8Array(await response.arrayBuffer());
+    });
+  }
+  async requestWithParser(options, accept, parseSuccess) {
     const url = this.buildUrl(options.path, options.query);
     let lastError;
     const methodOpts = options.methodOptions;
@@ -557,7 +739,7 @@ var ShipMailClient = class {
           ...this.defaultHeaders,
           Authorization: `Bearer ${this.apiKey}`,
           "User-Agent": `shipmail-node/${VERSION}`,
-          Accept: "application/json",
+          Accept: accept,
           ...methodOpts?.headers
         };
         if (methodOpts?.idempotencyKey) {
@@ -583,11 +765,8 @@ var ShipMailClient = class {
         if (attempt < this.maxRetries) continue;
         throw lastError;
       }
-      if (response.status === 204) {
-        return void 0;
-      }
       if (response.ok) {
-        return await response.json();
+        return parseSuccess(response);
       }
       let errorBody;
       try {
@@ -639,12 +818,14 @@ var WEBHOOK_EVENT_TYPES = [
 ];
 var DOMAIN_STATUSES = ["pending", "verifying", "verified", "degraded", "failed"];
 var MESSAGE_STATUSES = [
+  "scheduled",
   "queued",
   "sent",
   "delivered",
   "bounced",
   "complained",
-  "failed"
+  "failed",
+  "cancelled"
 ];
 var MESSAGE_SOURCES = ["api", "dashboard", "inbound", "smtp"];
 var WEBHOOK_DELIVERY_STATUSES = ["pending", "delivered", "failed"];