@stackshift-cloud/sdk 1.3.1 → 1.4.1

package/dist/mail-campaigns.d.ts

@@ -40,6 +40,9 @@ export interface MailAudienceMemberImport {
     consentIp?: string;
     attributes?: Record<string, string>;
 }
+export interface MailBrandFilterOptions {
+    brandId?: string;
+}
 export interface MailCampaignContent {
     subject: string;
     previewText?: string;
@@ -50,7 +53,7 @@ export interface MailCampaignContent {
 }
 export interface MailCampaignInput {
     simulation?: MailSimulationOptions;
-    name: string;
+    name?: string;
     audienceId: string;
     segmentId?: string;
     from?: string;
@@ -95,7 +98,7 @@ export declare class MailAudiencesClient {
         name: string;
         description?: string;
     }): Promise<MailAudience>;
-    list(): Promise<{
+    list(options?: MailBrandFilterOptions): Promise<{
         data: MailAudience[];
     }>;
     get(id: string): Promise<MailAudience>;
@@ -116,7 +119,7 @@ export declare class MailCampaignsClient {
     private readonly client;
     constructor(client: StackShift);
     create(input: MailCampaignInput): Promise<MailCampaign>;
-    list(): Promise<{
+    list(options?: MailBrandFilterOptions): Promise<{
         data: MailCampaign[];
     }>;
     get(id: string): Promise<MailCampaign>;

package/dist/mail-campaigns.js

@@ -6,8 +6,9 @@ export class MailAudiencesClient {
     create(input) {
         return this.client.mailRequest('/mail/audiences', { method: 'POST', body: input });
     }
-    list() {
-        return this.client.mailRequest('/mail/audiences');
+    list(options = {}) {
+        const query = options.brandId ? `?brandId=${encodeURIComponent(options.brandId)}` : '';
+        return this.client.mailRequest(`/mail/audiences${query}`);
     }
     get(id) {
         return this.client.mailRequest(`/mail/audiences/${encodeURIComponent(id)}`);
@@ -39,8 +40,9 @@ export class MailCampaignsClient {
     create(input) {
         return this.client.mailRequest('/mail/campaigns', { method: 'POST', body: input });
     }
-    list() {
-        return this.client.mailRequest('/mail/campaigns');
+    list(options = {}) {
+        const query = options.brandId ? `?brandId=${encodeURIComponent(options.brandId)}` : '';
+        return this.client.mailRequest(`/mail/campaigns${query}`);
     }
     get(id) {
         return this.client.mailRequest(`/mail/campaigns/${encodeURIComponent(id)}`);

package/dist/mail-delivery-types.d.ts

@@ -14,6 +14,7 @@ export interface MailSuppression {
 export interface MailSuppressionListOptions {
     email?: string;
     reason?: MailSuppressionReason;
+    brandId?: string;
     limit?: number;
     cursor?: string;
 }

package/dist/mail-events-webhooks.d.ts

@@ -1,5 +1,5 @@
 import type { StackShift } from './client.js';
-import type { MailEvent, MailEventListOptions, MailEventListResult, MailTimelineItem, MailWebhook, MailWebhookCreateInput, MailWebhookCreateResponse, MailWebhookDelivery, MailWebhookDeliveryDetail, MailWebhookDeliveryListOptions, MailWebhookListOptions, MailWebhookListResult, MailWebhookReplay, MailWebhookReplayInput, MailWebhookUpdateInput } from './mail-webhook-types.js';
+import type { MailEvent, MailEventListOptions, MailEventListResult, MailTimelineItem, MailWebhook, MailWebhookCreateInput, MailWebhookCreateResponse, MailWebhookDelivery, MailWebhookDeliveryDetail, MailWebhookDeliveryListItem, MailWebhookDeliveryListOptions, MailWebhookDetail, MailWebhookDiagnosisResult, MailWebhookListOptions, MailWebhookListResult, MailWebhookReplay, MailWebhookReplayInput, MailWebhookUpdateInput } from './mail-webhook-types.js';
 export declare class MailEventsClient {
     private readonly client;
     constructor(client: StackShift);
@@ -11,14 +11,19 @@ export declare class MailWebhooksClient {
     constructor(client: StackShift);
     create(input: MailWebhookCreateInput): Promise<MailWebhookCreateResponse>;
     list(options?: MailWebhookListOptions): Promise<MailWebhookListResult>;
-    get(webhookId: string): Promise<MailWebhook>;
+    get(webhookId: string): Promise<MailWebhookDetail>;
     update(webhookId: string, input: MailWebhookUpdateInput): Promise<MailWebhook>;
     rotateSecret(webhookId: string): Promise<{
         secret: string;
     }>;
+    revealSecret(webhookId: string): Promise<{
+        secret: string;
+    }>;
+    diagnosis(webhookId: string): Promise<MailWebhookDiagnosisResult>;
+    diagnose(webhookId: string): Promise<MailWebhookDiagnosisResult>;
     delete(webhookId: string): Promise<void>;
     deliveries(webhookId: string, options?: MailWebhookDeliveryListOptions): Promise<{
-        data: MailWebhookDelivery[];
+        data: MailWebhookDeliveryListItem[];
         nextCursor?: string | null;
     }>;
     getDelivery(deliveryId: string): Promise<MailWebhookDeliveryDetail>;

package/dist/mail-events-webhooks.js

@@ -39,6 +39,19 @@ export class MailWebhooksClient {
             method: 'POST',
         });
     }
+    revealSecret(webhookId) {
+        return this.client.mailRequest(`/mail/webhooks/${encodeURIComponent(webhookId)}/reveal-secret`, {
+            method: 'POST',
+        });
+    }
+    diagnosis(webhookId) {
+        return this.client.mailRequest(`/mail/webhooks/${encodeURIComponent(webhookId)}/diagnosis`);
+    }
+    diagnose(webhookId) {
+        return this.client.mailRequest(`/mail/webhooks/${encodeURIComponent(webhookId)}/diagnosis`, {
+            method: 'POST',
+        });
+    }
     delete(webhookId) {
         return this.client.mailRequest(`/mail/webhooks/${encodeURIComponent(webhookId)}`, {
             method: 'DELETE',

package/dist/mail-mailboxes.d.ts

@@ -0,0 +1,358 @@
+import type { StackShift } from './client.js';
+export type MailboxDomainStatus = 'pending' | 'receiving' | 'mx_lost' | 'disabled';
+export type MailboxStatus = 'active' | 'suspended' | 'pending' | 'deleted';
+export type MailboxKind = 'person' | 'shared';
+export type MailboxPlanSlug = 'basic' | 'pro';
+export type MailboxRouteTargetKind = 'mailbox' | 'group' | 'app' | 'support' | 'forward' | 'reject';
+export interface MailboxRouteTarget {
+    kind: MailboxRouteTargetKind;
+    mailboxId?: string;
+    groupId?: string;
+    webhookUrl?: string;
+    supportChannelId?: string;
+    forwardTo?: string;
+}
+export interface MailboxDnsRecord {
+    type: string;
+    name: string;
+    value: string;
+    priority?: number;
+    status: string;
+    required: boolean;
+    explanation?: string;
+}
+export interface MailboxDomain {
+    id: string;
+    workspaceId: string;
+    domain: string;
+    status: MailboxDomainStatus;
+    mxVerifiedAt?: string;
+    catchAll?: MailboxRouteTarget;
+    retentionDays?: number;
+    addonStorageUnits: number;
+    quotaPoolBytes: number;
+    usedBytes: number;
+    verificationToken: string;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+    records: MailboxDnsRecord[];
+    foundMx: string | null;
+    dns: {
+        cloudflareConnected: boolean;
+        lastApplied: {
+            at: string;
+            byName: string;
+            recordCount: number;
+        } | null;
+    };
+}
+export interface MailboxDomainUpdateInput {
+    catchAll?: MailboxRouteTarget | null;
+    retentionDays?: number | null;
+    addonStorageUnits?: number;
+}
+export interface MailboxInvitation {
+    email: string;
+    expiresAt: string;
+    expired: boolean;
+}
+export interface Mailbox {
+    id: string;
+    workspaceId: string;
+    domainId: string;
+    localPart: string;
+    address: string;
+    displayName: string;
+    kind: MailboxKind;
+    ownerUserId?: string;
+    quotaBytes: number;
+    usedBytes: number;
+    plan: MailboxPlanSlug;
+    status: MailboxStatus;
+    aiEnabled: boolean;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+    invitation: MailboxInvitation | null;
+    aiMicrocreditsThisMonth: number | null;
+}
+export interface MailboxCreateInput {
+    domainId: string;
+    localPart: string;
+    displayName?: string;
+    kind?: MailboxKind;
+    ownerUserId?: string;
+    ownerEmail?: string;
+    plan?: MailboxPlanSlug;
+    quotaBytes?: number;
+    aiEnabled?: boolean;
+}
+export interface MailboxUpdateInput {
+    displayName?: string;
+    quotaBytes?: number;
+    aiEnabled?: boolean;
+    plan?: MailboxPlanSlug;
+}
+export interface MailboxMember {
+    mailboxId: string;
+    userId: string;
+    role: 'owner' | 'member';
+    createdAt: string;
+}
+export interface MailboxAppPassword {
+    id: string;
+    mailboxId: string;
+    label: string;
+    lastUsedAt?: string;
+    createdAt: string;
+    revokedAt?: string;
+}
+export interface MailboxAppPasswordCreated extends MailboxAppPassword {
+    secret: string;
+}
+export interface MailboxDevice {
+    id: string;
+    kind: 'app_password' | 'web';
+    label: string;
+    lastUsedAt: string | null;
+    createdAt: string;
+}
+export interface MailboxPasswordReset {
+    password: string;
+    appliedNow: boolean;
+}
+export interface MailboxProfileLink {
+    url: string;
+    expiresAt: string;
+}
+export interface MailboxPlan {
+    slug: MailboxPlanSlug;
+    quotaBytes: number;
+    monthlyPriceKobo: number;
+}
+export interface MailboxPricing {
+    plans: MailboxPlan[];
+    addonUnitBytes: number;
+    addonPriceKobo: number;
+    pricesArePlaceholders: boolean;
+}
+export interface MailboxClientEndpoint {
+    host: string;
+    port: number;
+    security: string;
+}
+export interface MailboxClientSettings {
+    incoming: MailboxClientEndpoint | null;
+    outgoing: MailboxClientEndpoint | null;
+}
+export interface MailboxUsage {
+    mailboxLimit: number;
+    mailboxesUsed: number;
+    ai: {
+        availableMicrocredits: number;
+        usedThisMonthMicrocredits: number;
+        nextReset: string;
+    } | null;
+}
+export interface MailboxAlias {
+    id: string;
+    mailboxId: string;
+    address: string;
+    sendAs: boolean;
+    createdAt: string;
+}
+export interface MailboxAliasCreateInput {
+    mailboxId: string;
+    localPart: string;
+    domainId?: string;
+    sendAs?: boolean;
+}
+export interface MailboxGroup {
+    id: string;
+    domainId: string;
+    address: string;
+    displayName: string;
+    memberIds: string[];
+    moderatorId?: string;
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MailboxGroupCreateInput {
+    domainId: string;
+    localPart: string;
+    displayName?: string;
+    memberIds?: string[];
+    moderatorId?: string;
+}
+export interface MailboxGroupUpdateInput {
+    displayName?: string;
+    moderatorId?: string | null;
+    memberIds?: string[];
+}
+export interface MailboxRoute {
+    id: string;
+    domainId: string;
+    pattern: string;
+    priority: number;
+    targets: MailboxRouteTarget[];
+    revision: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MailboxRouteCreateInput {
+    domainId: string;
+    pattern: string;
+    priority?: number;
+    targets: MailboxRouteTarget[];
+}
+export interface MailboxRouteUpdateInput {
+    priority?: number;
+    targets?: MailboxRouteTarget[];
+}
+export interface MailboxAppHealthIssue {
+    routeId: string;
+    address: string;
+    since: string;
+    undeliveredCount: number;
+    holderName: string | null;
+    url: string;
+    lastError: string;
+    endpointId: string;
+}
+export type MailboxImportSource = 'google' | 'microsoft' | 'stackshift-hosting' | 'imap';
+export interface MailboxImportAccountInput {
+    mailboxId: string;
+    username: string;
+    password: string;
+}
+export interface MailboxImportStartInput {
+    domainId: string;
+    source: MailboxImportSource;
+    host?: string;
+    port?: number;
+    accounts: MailboxImportAccountInput[];
+}
+export interface MailboxImportMailbox {
+    mailboxId: string;
+    address: string;
+    sourceUsername: string;
+    state: 'pending' | 'copying' | 'copied' | 'refused' | 'skipped' | 'failed' | 'cancelled';
+    totalEmails: number;
+    copiedEmails: number;
+    totalBytes: number;
+    copiedBytes: number;
+    minutesLeft: number | null;
+    message: string | null;
+}
+export interface MailboxImport {
+    id: string;
+    domainId: string;
+    domain: string;
+    source: MailboxImportSource;
+    sourceLabel: string;
+    host: string;
+    createdAt: string;
+    updatedAt: string;
+    stage: 'copy' | 'switch' | 'done' | 'cancelled';
+    switch: {
+        requestedFor: string | null;
+        scheduledAt: string | null;
+        switchedAt: string | null;
+    };
+    mailboxes: MailboxImportMailbox[];
+}
+interface MailboxList<T> {
+    data: T[];
+}
+export declare class MailboxDomainsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(domain: string): Promise<MailboxDomain>;
+    list(): Promise<MailboxList<MailboxDomain>>;
+    get(domainId: string): Promise<MailboxDomain>;
+    update(domainId: string, input: MailboxDomainUpdateInput): Promise<MailboxDomain>;
+    verify(domainId: string): Promise<MailboxDomain>;
+    applyDns(domainId: string): Promise<MailboxDomain>;
+    dnsApplications(domainId: string): Promise<MailboxList<Record<string, unknown>>>;
+    delete(domainId: string): Promise<void>;
+}
+export declare class MailboxesClient {
+    private readonly client;
+    constructor(client: StackShift);
+    plans(): Promise<MailboxPricing>;
+    clientSettings(): Promise<MailboxClientSettings>;
+    usage(): Promise<MailboxUsage>;
+    create(input: MailboxCreateInput): Promise<Mailbox>;
+    list(options?: {
+        domainId?: string;
+    }): Promise<MailboxList<Mailbox>>;
+    get(mailboxId: string): Promise<Mailbox>;
+    update(mailboxId: string, input: MailboxUpdateInput): Promise<Mailbox>;
+    delete(mailboxId: string): Promise<void>;
+    suspend(mailboxId: string): Promise<Mailbox>;
+    resume(mailboxId: string): Promise<Mailbox>;
+    resendInvitation(mailboxId: string): Promise<Mailbox>;
+    resetPassword(mailboxId: string): Promise<MailboxPasswordReset>;
+    createProfileLink(mailboxId: string): Promise<MailboxProfileLink>;
+    listDevices(mailboxId: string): Promise<MailboxList<MailboxDevice>>;
+    revokeDevice(mailboxId: string, kind: MailboxDevice['kind'], deviceId: string): Promise<void>;
+    listMembers(mailboxId: string): Promise<MailboxList<MailboxMember>>;
+    addMember(mailboxId: string, userId: string): Promise<MailboxMember>;
+    removeMember(mailboxId: string, userId: string): Promise<void>;
+    listAppPasswords(mailboxId: string): Promise<MailboxList<MailboxAppPassword>>;
+    createAppPassword(mailboxId: string, label: string): Promise<MailboxAppPasswordCreated>;
+    revokeAppPassword(mailboxId: string, passwordId: string): Promise<void>;
+}
+export declare class MailboxAliasesClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(input: MailboxAliasCreateInput): Promise<MailboxAlias>;
+    list(options?: {
+        mailboxId?: string;
+    }): Promise<MailboxList<MailboxAlias>>;
+    update(aliasId: string, input: {
+        sendAs: boolean;
+    }): Promise<MailboxAlias>;
+    delete(aliasId: string): Promise<void>;
+}
+export declare class MailboxGroupsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(input: MailboxGroupCreateInput): Promise<MailboxGroup>;
+    list(options?: {
+        domainId?: string;
+    }): Promise<MailboxList<MailboxGroup>>;
+    get(groupId: string): Promise<MailboxGroup>;
+    update(groupId: string, input: MailboxGroupUpdateInput): Promise<MailboxGroup>;
+    delete(groupId: string): Promise<void>;
+}
+export declare class MailboxRoutesClient {
+    private readonly client;
+    constructor(client: StackShift);
+    create(input: MailboxRouteCreateInput): Promise<MailboxRoute>;
+    list(options?: {
+        domainId?: string;
+    }): Promise<MailboxList<MailboxRoute>>;
+    get(routeId: string): Promise<MailboxRoute>;
+    update(routeId: string, input: MailboxRouteUpdateInput): Promise<MailboxRoute>;
+    delete(routeId: string): Promise<void>;
+    appHealth(domainId: string): Promise<{
+        issue: MailboxAppHealthIssue | null;
+    }>;
+    retryDeliveries(routeId: string): Promise<{
+        retried: number;
+    }>;
+}
+export declare class MailboxImportsClient {
+    private readonly client;
+    constructor(client: StackShift);
+    start(input: MailboxImportStartInput): Promise<MailboxImport>;
+    list(): Promise<MailboxList<MailboxImport>>;
+    get(importId: string): Promise<MailboxImport>;
+    cancel(importId: string): Promise<MailboxImport>;
+    skip(importId: string, mailboxId: string): Promise<MailboxImport>;
+    switch(importId: string, when: 'now' | 'tonight'): Promise<MailboxImport>;
+}
+export {};

package/dist/mail-mailboxes.js

@@ -0,0 +1,202 @@
+function path(...parts) {
+    return parts.map(encodeURIComponent).join('/');
+}
+function query(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined) {
+            search.append(key, value);
+        }
+    }
+    const suffix = search.toString();
+    return suffix ? `?${suffix}` : '';
+}
+export class MailboxDomainsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(domain) {
+        return this.client.mailRequest('/mail/mailbox-domains', { method: 'POST', body: { domain } });
+    }
+    list() {
+        return this.client.mailRequest('/mail/mailbox-domains');
+    }
+    get(domainId) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}`);
+    }
+    update(domainId, input) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}`, { method: 'PATCH', body: input });
+    }
+    verify(domainId) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}/verify`, { method: 'POST' });
+    }
+    applyDns(domainId) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}/dns/apply`, { method: 'POST' });
+    }
+    dnsApplications(domainId) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}/dns/applications`);
+    }
+    delete(domainId) {
+        return this.client.mailRequest(`/mail/mailbox-domains/${path(domainId)}`, { method: 'DELETE' });
+    }
+}
+export class MailboxesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    plans() {
+        return this.client.mailRequest('/mail/mailbox-plans');
+    }
+    clientSettings() {
+        return this.client.mailRequest('/mail/mailbox-client-settings');
+    }
+    usage() {
+        return this.client.mailRequest('/mail/mailbox-usage');
+    }
+    create(input) {
+        return this.client.mailRequest('/mail/mailboxes', { method: 'POST', body: input });
+    }
+    list(options = {}) {
+        return this.client.mailRequest(`/mail/mailboxes${query({ domainId: options.domainId })}`);
+    }
+    get(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}`);
+    }
+    update(mailboxId, input) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}`, { method: 'PATCH', body: input });
+    }
+    delete(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}`, { method: 'DELETE' });
+    }
+    suspend(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/suspend`, { method: 'POST' });
+    }
+    resume(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/resume`, { method: 'POST' });
+    }
+    resendInvitation(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/invitation/resend`, { method: 'POST' });
+    }
+    resetPassword(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/password-reset`, { method: 'POST' });
+    }
+    createProfileLink(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/mobileconfig`, { method: 'POST' });
+    }
+    listDevices(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/devices`);
+    }
+    revokeDevice(mailboxId, kind, deviceId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/devices/${path(kind, deviceId)}`, { method: 'DELETE' });
+    }
+    listMembers(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/members`);
+    }
+    addMember(mailboxId, userId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/members`, { method: 'POST', body: { userId } });
+    }
+    removeMember(mailboxId, userId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/members/${path(userId)}`, { method: 'DELETE' });
+    }
+    listAppPasswords(mailboxId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/app-passwords`);
+    }
+    createAppPassword(mailboxId, label) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/app-passwords`, { method: 'POST', body: { label } });
+    }
+    revokeAppPassword(mailboxId, passwordId) {
+        return this.client.mailRequest(`/mail/mailboxes/${path(mailboxId)}/app-passwords/${path(passwordId)}`, { method: 'DELETE' });
+    }
+}
+export class MailboxAliasesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.mailRequest('/mail/aliases', { method: 'POST', body: input });
+    }
+    list(options = {}) {
+        return this.client.mailRequest(`/mail/aliases${query({ mailboxId: options.mailboxId })}`);
+    }
+    update(aliasId, input) {
+        return this.client.mailRequest(`/mail/aliases/${path(aliasId)}`, { method: 'PATCH', body: input });
+    }
+    delete(aliasId) {
+        return this.client.mailRequest(`/mail/aliases/${path(aliasId)}`, { method: 'DELETE' });
+    }
+}
+export class MailboxGroupsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.mailRequest('/mail/groups', { method: 'POST', body: input });
+    }
+    list(options = {}) {
+        return this.client.mailRequest(`/mail/groups${query({ domainId: options.domainId })}`);
+    }
+    get(groupId) {
+        return this.client.mailRequest(`/mail/groups/${path(groupId)}`);
+    }
+    update(groupId, input) {
+        return this.client.mailRequest(`/mail/groups/${path(groupId)}`, { method: 'PATCH', body: input });
+    }
+    delete(groupId) {
+        return this.client.mailRequest(`/mail/groups/${path(groupId)}`, { method: 'DELETE' });
+    }
+}
+export class MailboxRoutesClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    create(input) {
+        return this.client.mailRequest('/mail/routes', { method: 'POST', body: input });
+    }
+    list(options = {}) {
+        return this.client.mailRequest(`/mail/routes${query({ domainId: options.domainId })}`);
+    }
+    get(routeId) {
+        return this.client.mailRequest(`/mail/routes/${path(routeId)}`);
+    }
+    update(routeId, input) {
+        return this.client.mailRequest(`/mail/routes/${path(routeId)}`, { method: 'PATCH', body: input });
+    }
+    delete(routeId) {
+        return this.client.mailRequest(`/mail/routes/${path(routeId)}`, { method: 'DELETE' });
+    }
+    appHealth(domainId) {
+        return this.client.mailRequest(`/mail/routes/app-health${query({ domainId })}`);
+    }
+    retryDeliveries(routeId) {
+        return this.client.mailRequest(`/mail/routes/${path(routeId)}/retry-deliveries`, { method: 'POST' });
+    }
+}
+export class MailboxImportsClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    start(input) {
+        return this.client.mailRequest('/mail/mailbox-imports', { method: 'POST', body: input });
+    }
+    list() {
+        return this.client.mailRequest('/mail/mailbox-imports');
+    }
+    get(importId) {
+        return this.client.mailRequest(`/mail/mailbox-imports/${path(importId)}`);
+    }
+    cancel(importId) {
+        return this.client.mailRequest(`/mail/mailbox-imports/${path(importId)}/cancel`, { method: 'POST' });
+    }
+    skip(importId, mailboxId) {
+        return this.client.mailRequest(`/mail/mailbox-imports/${path(importId)}/mailboxes/${path(mailboxId)}/skip`, { method: 'POST' });
+    }
+    switch(importId, when) {
+        return this.client.mailRequest(`/mail/mailbox-imports/${path(importId)}/switch`, { method: 'POST', body: { when } });
+    }
+}