@openemail/sdk 0.0.1

package/index.d.cts

@@ -0,0 +1,1531 @@
+/// <reference lib="dom" />
+type AddressResource = {
+    object: 'address';
+    address: string;
+    enabled: boolean;
+    canSend: boolean;
+};
+
+type SendableDomainResource = {
+    domain: string;
+    receivingVerified: boolean;
+    sendingVerified: boolean;
+    catchAll: boolean;
+};
+
+type AddressBookResource = {
+    unrestricted: boolean;
+    addresses: Array<AddressResource>;
+    domains: Array<SendableDomainResource>;
+};
+
+type CalendarAttendeeResource = {
+    object: 'calendar_attendee';
+    email: string;
+    name: string | null;
+    partstat: string;
+    role: string;
+    rsvp: boolean;
+    cutype: string | null;
+    respondedAt: string | null;
+};
+
+type CalendarEventResource = {
+    object: 'calendar_event';
+    id: string;
+    uid: string;
+    sequence: number;
+    summary: string | null;
+    description: string | null;
+    location: string | null;
+    url: string | null;
+    start: string;
+    end: string;
+    allDay: boolean;
+    timezone: string | null;
+    recurrence: string | null;
+    exdates: Array<string>;
+    status: string;
+    transparency: string;
+    visibility: string;
+    organizer: {
+        email: string;
+        name: string | null;
+    } | null;
+    isOrganizer: boolean;
+    source: string;
+    messageId: string | null;
+    threadId: string | null;
+    alarms: Array<{
+        minutesBefore: number;
+        action: string;
+    }>;
+    attendees: Array<CalendarAttendeeResource>;
+    createdAt: string;
+    updatedAt: string;
+};
+
+type CalendarOccurrenceResource = {
+    object: 'calendar_occurrence';
+    eventId: string;
+    uid: string;
+    start: string;
+    end: string;
+    allDay: boolean;
+    summary: string | null;
+    location: string | null;
+    status: string;
+    transparency: string;
+    isOrganizer: boolean;
+    organizerEmail: string | null;
+    recurring: boolean;
+    myPartstat: string | null;
+    attendeeCount: number;
+};
+
+type RequestScope = {
+    signal?: AbortSignal;
+    apiKey?: string;
+};
+
+type CalendarRangeOptions = RequestScope & {
+    from: Date | string;
+    to: Date | string;
+    timezone?: string;
+};
+
+type ApiKeyMode = 'live' | 'test';
+
+declare const API_SCOPES: readonly ["emails:send", "emails:read", "drafts:read", "drafts:write", "threads:read", "threads:write", "labels:read", "labels:write", "contacts:read", "calendar:read", "calendar:write", "templates:read", "templates:write", "domains:read", "domains:write", "webhooks:read", "webhooks:write", "rules:read", "rules:write", "connections:read", "members:read", "members:write", "roles:read", "roles:write", "settings:read", "settings:write"];
+
+type ApiScope = (typeof API_SCOPES)[number];
+
+type AttachmentInput = {
+    filename: string;
+    content: string | Uint8Array | ArrayBuffer;
+    contentType?: string;
+};
+
+type AttachmentResource = {
+    object: 'attachment';
+    attachmentId: string;
+    filename: string;
+    contentType: string;
+    size: number;
+    content: string | null;
+};
+
+type BuiltinRole = 'owner' | 'admin' | 'member' | 'viewer' | 'developer' | 'billing';
+
+type HitKind = 'human' | 'proxy' | 'machine';
+
+declare const MESSAGE_ENCRYPTION_FORMATS: readonly ["pgp-mime", "pgp-signed", "pgp-inline", "smime-encrypted", "smime-signed"];
+
+type MessageEncryptionFormat = (typeof MESSAGE_ENCRYPTION_FORMATS)[number];
+
+type MessageEncryption = {
+    format: MessageEncryptionFormat;
+    detectedAt: string;
+    rawRetained: boolean;
+    parts?: Array<{
+        index: number;
+        attachmentId: string;
+        role: 'version' | 'ciphertext' | 'signature';
+    }>;
+};
+
+type MessageResource = Record<string, unknown> & {
+    encryption?: MessageEncryption;
+};
+
+type Permission = ApiScope | 'api-keys:read' | 'api-keys:write' | 'billing:read' | 'billing:write' | 'workspace:manage' | (string & {});
+
+type RecipientInput = string | {
+    email: string;
+    name?: string;
+};
+
+type TranslateOptions = {
+    to: string;
+    from?: string;
+    includeOriginal?: boolean;
+};
+
+type SendTranslateOptions = TranslateOptions & {
+    subject?: boolean;
+};
+
+type TrackingRequest = {
+    opens?: boolean;
+    clicks?: boolean;
+};
+
+type ContactListOptions = RequestScope & {
+    limit?: number;
+};
+
+type ContactResource = {
+    object: 'contact';
+    email: string;
+    name: string | null;
+    source: 'manual' | 'auto' | (string & {});
+    notes: string | null;
+    lastSeenAt: string | null;
+};
+
+type ApiErrorPayload = {
+    type?: string;
+    code?: string;
+    message?: string;
+    param?: string;
+    docUrl?: string;
+    requestId?: string;
+};
+
+declare const ERROR_TYPES: readonly ["invalid_request_error", "authentication_error", "permission_error", "not_found_error", "conflict_error", "validation_error", "rate_limit_error", "api_error"];
+
+type ErrorType = (typeof ERROR_TYPES)[number];
+
+type ApiErrorProps = {
+    message: string;
+    status: number | null;
+    type: ErrorType;
+    code: string;
+    param?: string;
+    docUrl?: string;
+    requestId?: string;
+    retryAfterSeconds?: number;
+};
+
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+type TransportOptions = {
+    apiKey?: string;
+    baseUrl?: string;
+    fetch?: FetchLike;
+    maxRetries?: number;
+    timeoutMs?: number;
+    userAgent?: string;
+    headers?: Record<string, string>;
+    disableUpdateNotice?: boolean;
+};
+
+type ClientOptions = TransportOptions & {
+    dangerouslyAllowBrowser?: boolean;
+};
+
+declare const Addresses: (transport: Transport) => {
+    list: (options?: RequestScope) => Promise<AddressBookResource>;
+};
+
+declare const Calendar: (transport: Transport) => {
+    listEvents: (options: CalendarRangeOptions) => Promise<Array<CalendarOccurrenceResource>>;
+    getEvent: (id: string, options?: RequestScope) => Promise<CalendarEventResource>;
+    getEventIcs: (id: string, options?: RequestScope) => Promise<string>;
+};
+
+declare const Contacts: (transport: Transport) => {
+    list: (options?: ContactListOptions) => Promise<Array<ContactResource>>;
+    get: (email: string, options?: RequestScope) => Promise<ContactResource>;
+};
+
+declare const Domains: (transport: Transport) => {
+    list: (options?: RequestScope) => Promise<Array<DomainResource>>;
+    get: (id: string, options?: RequestScope) => Promise<DomainDetailResource>;
+};
+
+declare const Drafts: (transport: Transport) => {
+    list: (options?: DraftListOptions) => Promise<Page<DraftSummaryResource>>;
+    listAll: (options?: DraftListOptions) => Promise<Array<DraftSummaryResource>>;
+    iterate: (options?: DraftListOptions) => AsyncGenerator<DraftSummaryResource, void, undefined>;
+    get: (id: string, options?: RequestScope) => Promise<DraftResource>;
+    create: (body: DraftInput, options?: RequestScope) => Promise<SavedDraftResource>;
+    update: (id: string, body: DraftInput, options?: RequestScope) => Promise<SavedDraftResource>;
+    delete: (id: string, options?: RequestScope) => Promise<DeletedDraftResource>;
+};
+
+declare const Emails: (transport: Transport) => {
+    send: (body: EmailSend, options?: SendScope) => Promise<SentEmailResource>;
+    sendBatch: (emails: Array<EmailSend>, options?: SendScope) => Promise<BatchResultResource>;
+    translate: (body: EmailTranslate, options?: RequestScope) => Promise<TranslationResource>;
+    list: (options?: EmailListOptions) => Promise<Page<EmailResource>>;
+    listAll: (options?: EmailListOptions) => Promise<Array<EmailResource>>;
+    iterate: (options?: EmailListOptions) => AsyncGenerator<EmailResource, void, undefined>;
+    get: (id: string, options?: RequestScope) => Promise<EmailResource>;
+    listEvents: (id: string, options?: RequestScope) => Promise<Array<EmailEventResource>>;
+    getTracking: (id: string, options?: RequestScope) => Promise<TrackingResource>;
+    cancel: (id: string, options?: RequestScope) => Promise<EmailResource>;
+    reschedule: (id: string, scheduledAt: Date | string, options?: RequestScope) => Promise<EmailResource>;
+};
+
+declare const Labels: (transport: Transport) => {
+    list: (options?: RequestScope) => Promise<Array<LabelResource>>;
+    get: (id: string, options?: RequestScope) => Promise<LabelResource>;
+    create: (body: LabelInput, options?: RequestScope) => Promise<SavedLabelResource>;
+    update: (id: string, body: LabelInput, options?: RequestScope) => Promise<SavedLabelResource>;
+    delete: (id: string, options?: RequestScope) => Promise<DeletedLabelResource>;
+};
+
+declare const Languages: (transport: Transport) => {
+    list: (options?: RequestScope) => Promise<Array<LanguageResource>>;
+};
+
+declare const Me: (transport: Transport) => {
+    get: (options?: RequestScope) => Promise<KeyResource>;
+    ping: (options?: RequestScope) => Promise<PingResource>;
+};
+
+declare const Members: (transport: Transport) => {
+    list: (options?: RequestScope) => Promise<Array<MemberResource>>;
+    get: (userId: string, options?: RequestScope) => Promise<MemberResource>;
+    add: (body: MemberAdd, options?: RequestScope) => Promise<MemberResource>;
+    update: (userId: string, patch: MemberPatch, options?: RequestScope) => Promise<MemberResource>;
+    remove: (userId: string, options?: RequestScope) => Promise<RemovedMemberResource>;
+    grantAddress: (userId: string, body: MemberAddressGrant, options?: RequestScope) => Promise<MemberResource>;
+    revokeAddress: (userId: string, addressId: string, options?: RequestScope) => Promise<MemberResource>;
+};
+
+declare const Roles: (transport: Transport) => {
+    list: (options?: RequestScope) => Promise<Array<RoleResource>>;
+    get: (id: string, options?: RequestScope) => Promise<RoleResource>;
+    create: (body: RoleCreate, options?: RequestScope) => Promise<RoleResource>;
+    update: (id: string, patch: RolePatch, options?: RequestScope) => Promise<RoleResource>;
+    delete: (id: string, options?: RoleDeleteOptions) => Promise<DeletedRoleResource>;
+    listPermissions: (options?: RequestScope) => Promise<Array<PermissionResource>>;
+};
+
+declare const Rules: (transport: Transport) => {
+    list: (options?: RuleListOptions) => Promise<Page<RuleResource>>;
+    listAll: (options?: RuleListOptions) => Promise<Array<RuleResource>>;
+    iterate: (options?: RuleListOptions) => AsyncGenerator<RuleResource, void, undefined>;
+    get: (id: string, options?: RequestScope) => Promise<RuleResource>;
+    create: (body: RuleCreate, options?: RequestScope) => Promise<RuleResource>;
+    update: (id: string, patch: RulePatch, options?: RequestScope) => Promise<RuleResource>;
+    delete: (id: string, options?: RequestScope) => Promise<DeletedRuleResource>;
+    reorder: (ruleIds: Array<string>, options?: RequestScope) => Promise<Array<RuleResource>>;
+    test: (id: string, body?: RuleTestInput, options?: RequestScope) => Promise<RuleTestResource>;
+    listRuns: (options?: RuleRunListOptions) => Promise<Page<RuleRunResource>>;
+    listAllRuns: (options?: RuleRunListOptions) => Promise<Array<RuleRunResource>>;
+    iterateRuns: (options?: RuleRunListOptions) => AsyncGenerator<RuleRunResource, void, undefined>;
+};
+
+declare const Settings: (transport: Transport) => {
+    get: (options?: RequestScope) => Promise<SettingsResource>;
+    update: (patch: SettingsPatch, options?: RequestScope) => Promise<SettingsResource>;
+};
+
+declare const TempMail: (transport: Transport) => {
+    listDomains: (options?: InboxScope) => Promise<Array<TempDomainResource>>;
+    create: (body?: TempInboxCreate, options?: InboxScope) => Promise<CreatedTempInboxResource>;
+    get: (inboxId: string, options?: InboxScope) => Promise<TempInboxResource>;
+    extend: (inboxId: string, options?: InboxScope) => Promise<TempInboxResource>;
+    delete: (inboxId: string, options?: InboxScope) => Promise<DeletedTempInboxResource>;
+    listMessages: (inboxId: string, options?: TempMessageListOptions) => Promise<TempMessagesResource>;
+    getMessage: (inboxId: string, messageId: string, options?: InboxScope) => Promise<TempMessageDetailResource>;
+    deleteMessage: (inboxId: string, messageId: string, options?: InboxScope) => Promise<DeletedTempMessageResource>;
+    listAttachments: (inboxId: string, messageId: string, options?: InboxScope) => Promise<Array<AttachmentResource>>;
+};
+
+declare const Templates: (transport: Transport) => {
+    list: (options?: TemplateListOptions) => Promise<Page<TemplateResource>>;
+    listAll: (options?: TemplateListOptions) => Promise<Array<TemplateResource>>;
+    iterate: (options?: TemplateListOptions) => AsyncGenerator<TemplateResource, void, undefined>;
+    get: (idOrSlug: string, options?: RequestScope) => Promise<TemplateDetailResource>;
+    create: (body: TemplateCreate, options?: RequestScope) => Promise<TemplateResource>;
+    update: (idOrSlug: string, patch: TemplatePatch, options?: RequestScope) => Promise<TemplateDetailResource>;
+    delete: (idOrSlug: string, options?: RequestScope) => Promise<DeletedTemplateResource>;
+    listVersions: (idOrSlug: string, options?: RequestScope) => Promise<Array<TemplateVersionResource>>;
+    publish: (idOrSlug: string, options?: RequestScope) => Promise<TemplateVersionResource>;
+    preview: (idOrSlug: string, body?: TemplatePreviewInput, options?: RequestScope) => Promise<TemplatePreviewResource>;
+    send: (idOrSlug: string, body: TemplateSend, options?: SendScope) => Promise<SentTemplateEmailResource>;
+};
+
+declare const Threads: (transport: Transport) => {
+    list: (options?: ThreadListOptions) => Promise<Page<ThreadSummaryResource>>;
+    listAll: (options?: ThreadListOptions) => Promise<Array<ThreadSummaryResource>>;
+    iterate: (options?: ThreadListOptions) => AsyncGenerator<ThreadSummaryResource, void, undefined>;
+    get: (id: string, options?: RequestScope) => Promise<ThreadResource>;
+    update: (id: string, patch: ThreadPatch, options?: RequestScope) => Promise<UpdatedThreadResource>;
+    trash: (id: string, options?: RequestScope) => Promise<TrashedThreadResource>;
+    snooze: (id: string, wakeAt: Date | string, options?: RequestScope) => Promise<SnoozedThreadResource>;
+    unsnooze: (id: string, options?: RequestScope) => Promise<SnoozedThreadResource>;
+    listAttachments: (id: string, messageId: string, options?: RequestScope) => Promise<Array<AttachmentResource>>;
+};
+
+declare const Tracking: (transport: Transport) => {
+    list: (options?: TrackingListOptions) => Promise<Array<TrackingResource>>;
+    getStats: (options?: TrackingStatsOptions) => Promise<TrackingStatsResource>;
+    get: (id: string, options?: RequestScope) => Promise<TrackingResource>;
+    listOpens: (id: string, options?: TrackingHitOptions) => Promise<Array<TrackingOpenResource>>;
+    listClicks: (id: string, options?: TrackingHitOptions) => Promise<Array<TrackingClickResource>>;
+};
+
+declare const Webhooks: (transport: Transport) => {
+    list: (options?: RequestScope) => Promise<Array<WebhookResource>>;
+    get: (id: string, options?: RequestScope) => Promise<WebhookResource>;
+    create: (body: WebhookCreate, options?: RequestScope) => Promise<CreatedWebhookResource>;
+    update: (id: string, patch: WebhookPatch, options?: RequestScope) => Promise<WebhookResource>;
+    delete: (id: string, options?: RequestScope) => Promise<DeletedWebhookResource>;
+    rotateSecret: (id: string, options?: RequestScope) => Promise<CreatedWebhookResource>;
+    test: (id: string, options?: RequestScope) => Promise<WebhookTestResource>;
+    listDeliveries: (id: string, options?: RequestScope) => Promise<Array<WebhookDeliveryResource>>;
+};
+
+declare class OpenEmail {
+    private readonly transport;
+    readonly mode: ApiKeyMode;
+    readonly me: ReturnType<typeof Me>;
+    readonly addresses: ReturnType<typeof Addresses>;
+    readonly languages: ReturnType<typeof Languages>;
+    readonly emails: ReturnType<typeof Emails>;
+    readonly templates: ReturnType<typeof Templates>;
+    readonly tracking: ReturnType<typeof Tracking>;
+    readonly threads: ReturnType<typeof Threads>;
+    readonly drafts: ReturnType<typeof Drafts>;
+    readonly labels: ReturnType<typeof Labels>;
+    readonly contacts: ReturnType<typeof Contacts>;
+    readonly domains: ReturnType<typeof Domains>;
+    readonly rules: ReturnType<typeof Rules>;
+    readonly webhooks: ReturnType<typeof Webhooks>;
+    readonly calendar: ReturnType<typeof Calendar>;
+    readonly settings: ReturnType<typeof Settings>;
+    readonly roles: ReturnType<typeof Roles>;
+    readonly members: ReturnType<typeof Members>;
+    readonly tempMail: ReturnType<typeof TempMail>;
+    constructor(configuration: ClientOptions | string);
+    get raw(): Transport;
+}
+
+type InboxScope = {
+    signal?: AbortSignal;
+    inboxToken?: string;
+};
+
+type ListOptions = RequestScope & {
+    limit?: number;
+    cursor?: string;
+};
+
+type Page<T> = {
+    items: Array<T>;
+    hasMore: boolean;
+    nextCursor: string | null;
+};
+
+type QueryValues = Record<string, string | number | boolean | null | undefined>;
+
+type RequestOptions = {
+    method?: string;
+    query?: QueryValues;
+    body?: unknown;
+    signal?: AbortSignal;
+    apiKey?: string;
+    inboxToken?: string;
+    anonymous?: boolean;
+    idempotent?: boolean;
+    idempotencyKey?: string;
+    repeatable?: boolean;
+    accept?: string;
+};
+
+type SendScope = RequestScope & {
+    idempotencyKey?: string;
+};
+
+type TempMailOptions = Omit<TransportOptions, 'apiKey'> & {
+    inboxToken?: string;
+};
+
+type DomainSendingState = 'verified' | 'pending' | 'failed' | 'no_identity' | 'unknown';
+
+type DomainResource = {
+    object: 'domain';
+    id: string;
+    domain: string;
+    receiving: {
+        verified: boolean;
+        verifiedAt: string | null;
+        catchAll: boolean;
+        lastCheckedAt: string | null;
+        error: string | null;
+    };
+    sending: {
+        status: DomainSendingState;
+        canSend: boolean;
+        checkedAt: string | null;
+        error: string | null;
+        note: string;
+    };
+    createdAt: string;
+};
+
+type DomainDetailResource = DomainResource & {
+    addresses: Array<{
+        address: string;
+        enabled: boolean;
+    }>;
+};
+
+type DeletedDraftResource = {
+    object: 'draft';
+    id: string;
+    deleted: true;
+};
+
+type DraftInput = {
+    to?: Array<string>;
+    cc?: Array<string>;
+    bcc?: Array<string>;
+    subject?: string;
+    html?: string;
+    text?: string;
+    from?: string;
+    threadId?: string;
+};
+
+type DraftListOptions = ListOptions & {
+    query?: string;
+};
+
+type DraftResource = {
+    object: 'draft';
+    id: string;
+    to: Array<string>;
+    cc: Array<string>;
+    bcc: Array<string>;
+    subject: string;
+    html: string;
+    threadId: string | null;
+    from: string | null;
+    attachments: Array<{
+        filename: string | null;
+        contentType: string | null;
+    }>;
+};
+
+type DraftSummaryResource = {
+    object: 'draft';
+    id: string;
+};
+
+type SavedDraftResource = {
+    object: 'draft';
+    id: string | null;
+};
+
+type RecipientStatus = 'pending' | 'suppressed' | 'delivered' | 'failed' | 'bounced' | 'complained' | 'uncertain';
+
+type EmailRecipientResource = {
+    email: string;
+    name: string | null;
+    kind: 'to' | 'cc' | 'bcc';
+    status: RecipientStatus;
+    error: string | null;
+    deliveredAt: string | null;
+};
+
+type EmailSource = 'composer' | 'api' | 'mcp' | 'ai' | 'queue';
+
+type EmailStatus = 'queued' | 'scheduled' | 'sending' | 'sent' | 'partial' | 'cancelled' | 'failed';
+
+type EmailTrackingSummary = {
+    opens: boolean;
+    clicks: boolean;
+    opened: boolean;
+    clicked: boolean;
+    openCount: number;
+    clickCount: number;
+    firstOpenAt: string | null;
+};
+
+type EmailTranslationResource = {
+    language: string;
+    languageName: string;
+    detectedSourceLanguage: string | null;
+    subject: boolean;
+    includeOriginal: boolean;
+};
+
+type EmailTransport = 'ses' | 'resend' | 'dev' | 'test';
+
+type TrackingLinkResource = {
+    id: string;
+    url: string;
+    label: string | null;
+    clickCount: number;
+    clickCountRaw: number;
+};
+
+type TrackingRecipientResource = {
+    email: string | null;
+    kind: 'to' | 'cc' | 'bcc' | null;
+    attributed: boolean;
+    openCount: number;
+    clickCount: number;
+    firstOpenAt: string | null;
+    lastOpenAt: string | null;
+    firstClickAt: string | null;
+    lastClickAt: string | null;
+};
+
+type TrackingSummary = {
+    id: string;
+    sendId: string | null;
+    threadId: string | null;
+    messageId: string | null;
+    subject: string | null;
+    from: string;
+    source: EmailSource | (string & {});
+    sentAt: string | null;
+    opens: boolean;
+    clicks: boolean;
+    opened: boolean;
+    clicked: boolean;
+    attributable: boolean;
+    openCount: number;
+    clickCount: number;
+    openCountRaw: number;
+    clickCountRaw: number;
+    firstOpenAt: string | null;
+    lastOpenAt: string | null;
+    firstClickAt: string | null;
+    lastClickAt: string | null;
+    recipients: Array<TrackingRecipientResource>;
+    links: Array<TrackingLinkResource>;
+};
+
+type EmailResource = {
+    object: 'email';
+    id: string;
+    status: EmailStatus;
+    mode: ApiKeyMode;
+    from: string;
+    subject: string | null;
+    messageId: string | null;
+    threadId: string | null;
+    transport: EmailTransport | (string & {}) | null;
+    attempts: number;
+    lastError: string | null;
+    scheduledAt: string | null;
+    cancellableUntil: string | null;
+    sentAt: string | null;
+    tags: Record<string, string>;
+    source: EmailSource | (string & {});
+    createdAt: string;
+    recipients?: Array<EmailRecipientResource>;
+    tracking?: EmailTrackingSummary | TrackingSummary;
+    translation?: EmailTranslationResource;
+};
+
+type SentEmailResource = EmailResource & {
+    replayed: boolean;
+};
+
+type BatchItemResource = {
+    index: number;
+    status: 'ok';
+    email: SentEmailResource;
+} | {
+    index: number;
+    status: 'error';
+    error: {
+        type: string;
+        code: string;
+        message: string;
+        param?: string;
+    };
+};
+
+type BatchResultResource = {
+    items: Array<BatchItemResource>;
+    sent: number;
+    failed: number;
+};
+
+type EmailEventResource = {
+    object: 'event';
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    createdAt: string;
+};
+
+type EmailListOptions = ListOptions & {
+    status?: EmailStatus | Array<EmailStatus>;
+    from?: string;
+};
+
+type EmailSend = {
+    from: RecipientInput;
+    to: RecipientInput | Array<RecipientInput>;
+    cc?: RecipientInput | Array<RecipientInput>;
+    bcc?: RecipientInput | Array<RecipientInput>;
+    replyTo?: RecipientInput;
+    subject?: string;
+    html?: string;
+    text?: string;
+    headers?: Record<string, string>;
+    attachments?: Array<AttachmentInput>;
+    threadId?: string;
+    draftId?: string;
+    template?: {
+        id: string;
+        version?: number;
+        props?: Record<string, unknown>;
+        slots?: Record<string, unknown>;
+    };
+    scheduledAt?: Date | string;
+    cancellableForSeconds?: number;
+    tracking?: TrackingRequest;
+    signature?: boolean;
+    tags?: Record<string, string>;
+    translate?: SendTranslateOptions;
+};
+
+type EmailTranslate = TranslateOptions & {
+    html?: string;
+    text?: string;
+    subject?: string;
+};
+
+type LanguageResource = {
+    code: string;
+    label: string;
+    native: string;
+    flag: string;
+    rtl: boolean;
+};
+
+type TranslationResource = {
+    object: 'translation';
+    language: LanguageResource;
+    detectedSourceLanguage: LanguageResource | null;
+    subject: string | null;
+    html: string | null;
+    text: string | null;
+    includeOriginal: boolean;
+};
+
+type DeletedLabelResource = {
+    object: 'label';
+    id: string;
+    deleted: true;
+};
+
+type LabelColor = {
+    backgroundColor: string;
+    textColor: string;
+};
+
+type LabelInput = {
+    name: string;
+    color?: LabelColor;
+};
+
+type LabelResource = {
+    object: 'label';
+    id: string;
+    name: string;
+    type: string;
+    color: LabelColor | null;
+};
+
+type SavedLabelResource = {
+    object: 'label';
+    id: string | null;
+    name: string;
+};
+
+type KeyResource = {
+    object: 'api_key';
+    id: string;
+    mode: ApiKeyMode;
+    scopes: Array<ApiScope>;
+    roleId: string | null;
+    grantedScopes: Array<ApiScope>;
+    workspaceId: string;
+    addressAllowlist: Array<string> | null;
+};
+
+type PingResource = {
+    ok: true;
+    keyId: string;
+    mode: ApiKeyMode;
+    scopes: Array<ApiScope>;
+    roleId: string | null;
+    grantedScopes: Array<ApiScope>;
+    workspaceId: string;
+};
+
+type MemberAccess = 'member' | 'viewer';
+
+type MemberAdd = {
+    email: string;
+    roleId: string;
+    addressIds?: Array<string>;
+    access?: MemberAccess;
+};
+
+type MemberAddressGrant = {
+    addressId: string;
+    access?: MemberAccess;
+};
+
+type MemberAddressResource = {
+    addressId: string;
+    address: string;
+    access: MemberAccess;
+};
+
+type MemberPatch = {
+    roleId: string;
+};
+
+type MemberResource = {
+    object: 'member';
+    userId: string;
+    email: string;
+    name: string | null;
+    image: string | null;
+    role: {
+        id: string | null;
+        name: string;
+        builtin: BuiltinRole | null;
+    };
+    implied: boolean;
+    permissions: Array<Permission>;
+    addresses: Array<MemberAddressResource>;
+    createdAt: string | null;
+};
+
+type RemovedMemberResource = {
+    object: 'member';
+    userId: string;
+    deleted: true;
+    addressesRevoked: number;
+};
+
+type DeletedRoleResource = {
+    object: 'role';
+    id: string;
+    deleted: true;
+    reassigned: number;
+    keysReassigned: number;
+};
+
+type PermissionResource = {
+    object: 'permission';
+    id: Permission;
+    label: string;
+    group: string;
+    scope: boolean;
+};
+
+type RoleCreate = {
+    name: string;
+    description?: string;
+    permissions: Array<Permission>;
+};
+
+type RoleDeleteOptions = RequestScope & {
+    reassignTo?: string;
+};
+
+type RolePatch = {
+    name?: string;
+    description?: string | null;
+    permissions?: Array<Permission>;
+};
+
+type RoleResource = {
+    object: 'role';
+    id: string;
+    name: string;
+    description: string | null;
+    permissions: Array<Permission>;
+    builtin: BuiltinRole | null;
+    editable: boolean;
+    deletable: boolean;
+    members: number;
+    apiKeys: number;
+    createdAt: string;
+    updatedAt: string;
+};
+
+type DeletedRuleResource = {
+    object: 'rule';
+    id: string;
+    deleted: true;
+};
+
+declare const RULE_FIELDS: readonly ["from", "from_domain", "envelope_from", "to", "cc", "bcc", "recipient", "reply_to", "delivered_to", "subject", "body", "header", "list_id", "attachment_name", "attachment_type", "has_attachment", "attachment_size", "message_size", "spam", "hour", "weekday"];
+declare const RULE_OPERATORS: readonly ["matches", "contains", "equals", "starts_with", "ends_with", "gt", "lt"];
+declare const RULE_ACTIONS: readonly ["label", "remove_label", "archive", "mark_read", "star", "spam", "trash", "forward", "reply", "block_sender", "reject"];
+
+type RuleActionType = (typeof RULE_ACTIONS)[number];
+
+type RuleAction = {
+    type: RuleActionType;
+    value?: string;
+};
+
+type RuleField = (typeof RULE_FIELDS)[number];
+
+type RuleOperator = (typeof RULE_OPERATORS)[number];
+
+type RuleCondition = {
+    field: RuleField;
+    op: RuleOperator;
+    value: string;
+    header?: string;
+    negate: boolean;
+};
+
+type RuleConditionInput = Partial<RuleCondition> & {
+    field: RuleField;
+    op: RuleOperator;
+    value: string;
+};
+
+type RuleCreate = {
+    name: string;
+    description?: string | null;
+    enabled?: boolean;
+    match?: 'all' | 'any';
+    conditions: Array<RuleConditionInput>;
+    actions: Array<RuleAction>;
+    stopProcessing?: boolean;
+};
+
+type RuleListOptions = ListOptions & {
+    enabled?: boolean;
+};
+
+type RulePatch = {
+    name?: string;
+    description?: string | null;
+    enabled?: boolean;
+    match?: 'all' | 'any';
+    conditions?: Array<RuleConditionInput>;
+    actions?: Array<RuleAction>;
+    stopProcessing?: boolean;
+    position?: number;
+};
+
+type RuleResource = {
+    object: 'rule';
+    id: string;
+    name: string;
+    description: string | null;
+    enabled: boolean;
+    position: number;
+    match: 'all' | 'any';
+    conditions: Array<RuleCondition>;
+    actions: Array<RuleAction>;
+    stopProcessing: boolean;
+    lastMatchedAt: string | null;
+    matchCount: number;
+    createdAt: string;
+    updatedAt: string;
+};
+
+type RuleRunListOptions = ListOptions & {
+    ruleId?: string;
+    threadId?: string;
+};
+
+type RuleRunResource = {
+    object: 'rule_run';
+    id: string;
+    ruleId: string;
+    ruleName: string;
+    threadId: string;
+    messageId: string | null;
+    sender: string;
+    subject: string;
+    actions: Array<string>;
+    failures: Array<string>;
+    createdAt: string;
+};
+
+type RuleTestInput = {
+    threadIds?: Array<string>;
+    days?: number;
+    limit?: number;
+};
+
+type RuleTestResource = {
+    object: 'rule_test';
+    ruleId: string;
+    scanned: number;
+    matched: number;
+    wouldApply: Array<string>;
+    messages: Array<{
+        threadId: string;
+        from: string;
+        subject: string;
+        receivedAt: string | null;
+    }>;
+    warnings: Array<{
+        code: 'forward_unverified' | 'field_unevaluable' | 'field_approximate' | 'forward_loop' | 'body_encrypted' | (string & {});
+        value: string;
+    }>;
+};
+
+type SettingsPatch = {
+    signature?: string;
+    openEmailSignature?: boolean;
+    timezone?: string;
+    language?: string;
+    defaultEmailAlias?: string;
+    trackOpens?: boolean;
+    trackClicks?: boolean;
+};
+
+type SettingsResource = {
+    object: 'settings';
+    signature: string;
+    openEmailSignature: boolean;
+    timezone: string;
+    language: string;
+    defaultEmailAlias: string;
+    trackOpens: boolean;
+    trackClicks: boolean;
+    [key: string]: unknown;
+};
+
+type DeletedTemplateResource = {
+    object: 'template';
+    id: string;
+    deleted: true;
+};
+
+type SentTemplateEmailResource = SentEmailResource & {
+    template: {
+        id: string;
+        version: number | null;
+    };
+};
+
+type TemplateEngine = 'blocks' | 'html';
+
+type TemplateValueKind = 'text' | 'url' | 'image';
+
+type TemplateProp = {
+    key: string;
+    label?: string;
+    kind: TemplateValueKind;
+    required: boolean;
+    default: string | null;
+};
+
+type TemplateSlot = {
+    key: string;
+    label?: string;
+    kind: TemplateValueKind;
+    default: string;
+};
+
+type TemplateContent = {
+    engine?: TemplateEngine;
+    subject?: string;
+    document?: Record<string, unknown>;
+    html?: string;
+    slots?: Array<Partial<TemplateSlot> & {
+        key: string;
+    }>;
+    props?: Array<Partial<TemplateProp> & {
+        key: string;
+    }>;
+};
+
+type TemplateCreate = TemplateContent & {
+    name: string;
+    slug?: string;
+    description?: string | null;
+    publish?: boolean;
+};
+
+type TemplateStatus = 'draft' | 'active' | 'archived';
+
+type TemplateResource = {
+    object: 'template';
+    id: string;
+    name: string;
+    slug: string;
+    description: string | null;
+    status: TemplateStatus;
+    publishedVersion: number | null;
+    latestVersion: number;
+    subject?: string;
+    engine?: TemplateEngine;
+    slots?: Array<TemplateSlot>;
+    props?: Array<TemplateProp>;
+    createdAt: string;
+    updatedAt: string;
+};
+
+type TemplateVersionResource = {
+    object: 'template_version';
+    id: string;
+    templateId: string;
+    version: number;
+    state: 'draft' | 'published';
+    engine: TemplateEngine;
+    subject: string;
+    slots: Array<TemplateSlot>;
+    props: Array<TemplateProp>;
+    document?: Record<string, unknown> | null;
+    html?: string | null;
+    publishedAt: string | null;
+    createdAt: string;
+    template?: TemplateResource;
+};
+
+type TemplateDetailResource = TemplateResource & {
+    latest: TemplateVersionResource;
+};
+
+type TemplateListOptions = ListOptions & {
+    status?: TemplateStatus;
+};
+
+type TemplatePatch = TemplateContent & {
+    name?: string;
+    description?: string | null;
+    status?: 'active' | 'archived';
+    expectedVersion?: number;
+};
+
+type TemplatePreviewInput = {
+    version?: number;
+    props?: Record<string, unknown>;
+    slots?: Record<string, unknown>;
+};
+
+type TemplatePreviewResource = {
+    object: 'template_preview';
+    templateId: string;
+    version: number;
+    subject: string;
+    html: string;
+    text: string;
+    warnings: Array<{
+        code: 'unfilled_placeholder' | (string & {});
+        key: string;
+    }>;
+};
+
+type TemplateSend = {
+    from: RecipientInput;
+    to: RecipientInput | Array<RecipientInput>;
+    cc?: RecipientInput | Array<RecipientInput>;
+    bcc?: RecipientInput | Array<RecipientInput>;
+    replyTo?: RecipientInput;
+    version?: number;
+    props?: Record<string, unknown>;
+    slots?: Record<string, unknown>;
+    subject?: string;
+    scheduledAt?: Date | string;
+    cancellableForSeconds?: number;
+    tracking?: TrackingRequest;
+    tags?: Record<string, string>;
+    translate?: SendTranslateOptions;
+};
+
+type TempInboxResource = {
+    object: 'temp_inbox';
+    id: string;
+    address: string;
+    domain: string;
+    createdAt: string;
+    expiresAt: string;
+    extensionsLeft: number;
+    messageCount: number;
+    messageLimit: number;
+    lastMessageAt: string | null;
+};
+
+type CreatedTempInboxResource = TempInboxResource & {
+    token: string;
+};
+
+type DeletedTempInboxResource = {
+    object: 'temp_inbox';
+    id: string;
+    destroyed: true;
+};
+
+type DeletedTempMessageResource = {
+    object: 'temp_message';
+    id: string;
+    deleted: true;
+};
+
+type TempDomainResource = {
+    object: 'temp_domain';
+    domain: string;
+};
+
+type TempInboxCreate = {
+    domain?: string;
+    localPart?: string;
+    ttlMinutes?: number;
+};
+
+type TempMessageResource = {
+    object: 'temp_message';
+    id: string;
+    from: {
+        name: string | null;
+        email: string;
+    };
+    to: string;
+    subject: string;
+    snippet: string;
+    spam: boolean;
+    seen: boolean;
+    attachmentCount: number;
+    sizeBytes: number;
+    receivedAt: string;
+};
+
+type TempMessageDetailResource = TempMessageResource & {
+    message: MessageResource;
+    truncated: boolean;
+};
+
+type TempMessageListOptions = InboxScope & {
+    limit?: number;
+};
+
+type TempMessagesResource = {
+    items: Array<TempMessageResource>;
+    expiresAt: string;
+};
+
+type SnoozedThreadResource = {
+    object: 'thread';
+    id: string;
+    snoozedUntil: string | null;
+};
+
+type ThreadListOptions = ListOptions & {
+    folder?: string;
+    query?: string;
+    labelIds?: string | Array<string>;
+};
+
+type ThreadPatch = {
+    read?: boolean;
+    addLabelIds?: Array<string>;
+    removeLabelIds?: Array<string>;
+};
+
+type ThreadResource = {
+    object: 'thread';
+    id: string;
+    messages: Array<MessageResource>;
+    labels: Array<{
+        id: string;
+        name: string;
+        color: string;
+    }>;
+    messageCount: number;
+    hasUnread: boolean;
+    totalReplies: number;
+};
+
+type ThreadSummaryResource = {
+    object: 'thread';
+    id: string;
+};
+
+type TrashedThreadResource = {
+    object: 'thread';
+    id: string;
+    trashed: true;
+};
+
+type UpdatedThreadResource = {
+    object: 'thread';
+    id: string;
+    addedLabelIds: Array<string>;
+    removedLabelIds: Array<string>;
+};
+
+type TrackingOpenResource = {
+    object: 'open';
+    id: string;
+    trackedMessageId: string;
+    recipient: string | null;
+    kind: HitKind;
+    counted: boolean;
+    userAgent: string | null;
+    client: string | null;
+    device: string | null;
+    os: string | null;
+    country: string | null;
+    region: string | null;
+    city: string | null;
+    createdAt: string;
+};
+
+type TrackingClickResource = Omit<TrackingOpenResource, 'object'> & {
+    object: 'click';
+    linkId: string;
+    url: string;
+};
+
+type TrackingGrain = 'minute' | 'hour' | 'day';
+
+type TrackingHitOptions = RequestScope & {
+    includeMachine?: boolean;
+    limit?: number;
+};
+
+type TrackingListOptions = RequestScope & {
+    opened?: boolean;
+    clicked?: boolean;
+    days?: number;
+    minutes?: number;
+    grain?: TrackingGrain;
+    limit?: number;
+};
+
+type TrackingResource = TrackingSummary & {
+    object: 'tracking';
+};
+
+type TrackingStatsOptions = RequestScope & {
+    days?: number;
+    minutes?: number;
+    grain?: TrackingGrain;
+    offsetMinutes?: number;
+};
+
+type TrackingStatsResource = {
+    object: 'tracking_stats';
+    tracked: number;
+    opened: number;
+    clicked: number;
+    trackedForOpens: number;
+    trackedForClicks: number;
+    openRate: number;
+    clickRate: number;
+    totalOpens: number;
+    totalClicks: number;
+    machineOpens: number;
+    medianTimeToOpenSeconds: number | null;
+    byDay: Array<{
+        day: string;
+        sent: number;
+        opened: number;
+        clicked: number;
+    }>;
+    hitsKnownFrom: string;
+    topLinks: Array<{
+        url: string;
+        label: string | null;
+        clickCount: number;
+    }>;
+    clients: Array<{
+        client: string;
+        count: number;
+    }>;
+    countries: Array<{
+        country: string;
+        count: number;
+    }>;
+};
+
+declare const WEBHOOK_EVENTS: readonly ["email.received", "email.sent", "email.failed", "email.cancelled", "email.scheduled", "email.queued", "email.bounced", "email.complained", "email.opened", "email.clicked"];
+
+type WebhookEvent = (typeof WEBHOOK_EVENTS)[number];
+
+type WebhookResource = {
+    object: 'webhook';
+    id: string;
+    url: string;
+    description: string | null;
+    eventTypes: Array<WebhookEvent> | ['*'];
+    enabled: boolean;
+    disabledAt: string | null;
+    disabledReason: string | null;
+    consecutiveFailures: number;
+    lastDeliveryAt: string | null;
+    createdAt: string;
+};
+
+type CreatedWebhookResource = WebhookResource & {
+    secret: string;
+};
+
+type DeletedWebhookResource = {
+    object: 'webhook';
+    id: string;
+    deleted: true;
+};
+
+type EmailOpenedData = {
+    emailId: string | null;
+    trackedMessageId: string;
+    threadId: string | null;
+    messageId: string | null;
+    subject: string | null;
+    from: string;
+    recipient: string | null;
+    attributed: boolean;
+    first: boolean;
+    client: string | null;
+    device: string | null;
+    os: string | null;
+    country: string | null;
+    via: HitKind;
+    openCount: number;
+    openedAt: string;
+};
+
+type EmailClickedData = Omit<EmailOpenedData, 'openCount' | 'openedAt'> & {
+    linkId: string;
+    url: string;
+    label: string | null;
+    clickCount: number;
+    clickedAt: string;
+};
+
+type WebhookSignatureHeaders = Record<string, string | Array<string> | undefined>;
+
+type VerifyWebhookProps = {
+    payload: string;
+    headers: WebhookSignatureHeaders | Headers;
+    secret: string;
+    toleranceSeconds?: number;
+};
+
+type WebhookCreate = {
+    url: string;
+    eventTypes?: Array<WebhookEvent>;
+    description?: string;
+};
+
+type WebhookDeliveryResource = {
+    object: 'webhook_delivery';
+    id: string;
+    eventType: WebhookEvent | (string & {});
+    status: 'delivered' | 'failed' | (string & {});
+    responseCode: number | null;
+    durationMs: number | null;
+    error: string | null;
+    createdAt: string;
+};
+
+type WebhookPatch = {
+    url?: string;
+    eventTypes?: Array<WebhookEvent>;
+    description?: string | null;
+    enabled?: boolean;
+};
+
+type WebhookPayload<T = Record<string, unknown>> = {
+    id: string;
+    type: WebhookEvent | (string & {});
+    createdAt: string;
+    data: T;
+};
+
+type WebhookTestResource = {
+    object: 'webhook_test';
+    id: string;
+    delivery: {
+        status: string;
+        responseCode: number | null;
+        durationMs: number | null;
+        error: string | null;
+    } | null;
+};
+
+declare class Transport {
+    #private;
+    readonly baseUrl: string;
+    private readonly fetchImpl;
+    private readonly maxRetries;
+    private readonly timeoutMs;
+    private readonly userAgent;
+    private readonly headers;
+    constructor(options: TransportOptions & {
+        inboxToken?: string;
+    });
+    request<T>(path: string, options?: RequestOptions): Promise<T>;
+    private headersFor;
+    private attempt;
+    private parse;
+}
+
+declare class OpenEmailApiError extends Error {
+    readonly status: number | null;
+    readonly type: ErrorType;
+    readonly code: string;
+    readonly param: string | undefined;
+    readonly docUrl: string | undefined;
+    readonly requestId: string | undefined;
+    readonly retryAfterSeconds: number | undefined;
+    constructor(props: ApiErrorProps);
+    get isAuth(): boolean;
+    get isPermission(): boolean;
+    get isScopeMissing(): boolean;
+    get isInvalidRequest(): boolean;
+    get isValidation(): boolean;
+    get isNotFound(): boolean;
+    get isConflict(): boolean;
+    get isRateLimited(): boolean;
+    get isServerError(): boolean;
+    get isRetryable(): boolean;
+}
+declare class OpenEmailNetworkError extends Error {
+    readonly cause: unknown;
+    readonly isTimeout: boolean;
+    constructor(message: string, cause?: unknown, isTimeout?: boolean);
+}
+
+declare const LANGUAGES: ReadonlyArray<LanguageResource>;
+
+declare const VERSION: string;
+
+declare const PAGE_LIMITS: {
+    MAX_LIMIT: number;
+    DEFAULT_LIMIT: number;
+};
+declare const WEBHOOK_SIGNATURE_HEADERS: {
+    SIGNATURE: string;
+    EVENT: string;
+    DELIVERY: string;
+};
+
+declare const init: (configuration?: ClientOptions | string) => OpenEmail;
+declare const openemail: OpenEmail;
+declare const getClient: () => OpenEmail;
+declare const resetClient: () => void;
+declare const createOpenEmail: (configuration?: ClientOptions | string) => OpenEmail;
+declare const createClient: (configuration?: ClientOptions | string) => OpenEmail;
+declare const createTempMail: (options?: TempMailOptions) => ReturnType<(transport: Transport) => {
+    listDomains: (options?: InboxScope) => Promise<Array<TempDomainResource>>;
+    create: (body?: TempInboxCreate, options?: InboxScope) => Promise<CreatedTempInboxResource>;
+    get: (inboxId: string, options?: InboxScope) => Promise<TempInboxResource>;
+    extend: (inboxId: string, options?: InboxScope) => Promise<TempInboxResource>;
+    delete: (inboxId: string, options?: InboxScope) => Promise<DeletedTempInboxResource>;
+    listMessages: (inboxId: string, options?: TempMessageListOptions) => Promise<TempMessagesResource>;
+    getMessage: (inboxId: string, messageId: string, options?: InboxScope) => Promise<TempMessageDetailResource>;
+    deleteMessage: (inboxId: string, messageId: string, options?: InboxScope) => Promise<DeletedTempMessageResource>;
+    listAttachments: (inboxId: string, messageId: string, options?: InboxScope) => Promise<Array<AttachmentResource>>;
+}>;
+declare const verifyWebhookSignature: <T = Record<string, unknown>>(props: VerifyWebhookProps) => Promise<WebhookPayload<T>>;
+declare const toBase64: (bytes: Uint8Array | ArrayBuffer) => string;
+declare const isApiKey: (value: unknown) => value is string;
+declare const isSealed: (message: Pick<MessageResource, "encryption">) => boolean;
+declare const resolveLanguage: (input: string | null | undefined) => LanguageResource | undefined;
+declare const languageByCode: (code: string | null | undefined) => LanguageResource | undefined;
+declare const isRtlLanguage: (code: string | null | undefined) => boolean;
+
+export { API_SCOPES, ERROR_TYPES, LANGUAGES, MESSAGE_ENCRYPTION_FORMATS, OpenEmail, OpenEmailApiError, OpenEmailNetworkError, PAGE_LIMITS, RULE_ACTIONS, RULE_FIELDS, RULE_OPERATORS, VERSION, WEBHOOK_EVENTS, WEBHOOK_SIGNATURE_HEADERS, createClient, createOpenEmail, createTempMail, OpenEmail as default, getClient, init, isApiKey, isRtlLanguage, isSealed, languageByCode, openemail, resetClient, resolveLanguage, toBase64, verifyWebhookSignature };
+export type { AddressBookResource, AddressResource, ApiErrorPayload, ApiErrorProps, ApiKeyMode, ApiScope, AttachmentInput, AttachmentResource, BatchItemResource, BatchResultResource, BuiltinRole, CalendarAttendeeResource, CalendarEventResource, CalendarOccurrenceResource, CalendarRangeOptions, ClientOptions, ContactListOptions, ContactResource, CreatedTempInboxResource, CreatedWebhookResource, DeletedDraftResource, DeletedLabelResource, DeletedRoleResource, DeletedRuleResource, DeletedTempInboxResource, DeletedTempMessageResource, DeletedTemplateResource, DeletedWebhookResource, DomainDetailResource, DomainResource, DomainSendingState, DraftInput, DraftListOptions, DraftResource, DraftSummaryResource, EmailClickedData, EmailEventResource, EmailListOptions, EmailOpenedData, EmailRecipientResource, EmailResource, EmailSend, EmailSource, EmailStatus, EmailTrackingSummary, EmailTranslate, EmailTranslationResource, EmailTransport, ErrorType, FetchLike, HitKind, InboxScope, KeyResource, LabelColor, LabelInput, LabelResource, LanguageResource, ListOptions, MemberAccess, MemberAdd, MemberAddressGrant, MemberAddressResource, MemberPatch, MemberResource, MessageEncryption, MessageEncryptionFormat, MessageResource, Page, Permission, PermissionResource, PingResource, RecipientInput, RecipientStatus, RemovedMemberResource, RequestOptions, RequestScope, RoleCreate, RoleDeleteOptions, RolePatch, RoleResource, RuleAction, RuleActionType, RuleCondition, RuleConditionInput, RuleCreate, RuleField, RuleListOptions, RuleOperator, RulePatch, RuleResource, RuleRunListOptions, RuleRunResource, RuleTestInput, RuleTestResource, SavedDraftResource, SavedLabelResource, SendScope, SendTranslateOptions, SendableDomainResource, SentEmailResource, SentTemplateEmailResource, SettingsPatch, SettingsResource, SnoozedThreadResource, TempDomainResource, TempInboxCreate, TempInboxResource, TempMailOptions, TempMessageDetailResource, TempMessageListOptions, TempMessageResource, TempMessagesResource, TemplateContent, TemplateCreate, TemplateDetailResource, TemplateEngine, TemplateListOptions, TemplatePatch, TemplatePreviewInput, TemplatePreviewResource, TemplateProp, TemplateResource, TemplateSend, TemplateSlot, TemplateStatus, TemplateValueKind, TemplateVersionResource, ThreadListOptions, ThreadPatch, ThreadResource, ThreadSummaryResource, TrackingClickResource, TrackingGrain, TrackingHitOptions, TrackingLinkResource, TrackingListOptions, TrackingOpenResource, TrackingRecipientResource, TrackingRequest, TrackingResource, TrackingStatsOptions, TrackingStatsResource, TrackingSummary, TranslateOptions, TranslationResource, TransportOptions, TrashedThreadResource, UpdatedThreadResource, VerifyWebhookProps, WebhookCreate, WebhookDeliveryResource, WebhookEvent, WebhookPatch, WebhookPayload, WebhookResource, WebhookSignatureHeaders, WebhookTestResource };